@fragno-dev/mcp-fragment 0.0.0-stage → 0.0.3

package/dist/browser/src-B6dHZXqB.js

@@ -0,0 +1,2303 @@
+import { defineFragment, defineRoutes } from "@fragno-dev/core";
+import "@fragno-dev/db";
+import "@modelcontextprotocol/client";
+import { z } from "zod";
+//#region ../fragno/dist/api/internal/path.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("/");
+}
+//#endregion
+//#region ../fragno/dist/api/request-body.js
+const isBinaryRequestBody = (body) => body instanceof ReadableStream || body instanceof Blob || body instanceof ArrayBuffer || ArrayBuffer.isView(body);
+const containsFileBody = (value) => {
+	if (value instanceof File || value instanceof Blob || value instanceof FormData) return true;
+	return typeof value === "object" && value !== null && Object.values(value).some((entry) => entry instanceof File || entry instanceof Blob || entry instanceof FormData);
+};
+const appendFormDataValue = (formData, key, value) => {
+	if (value instanceof File) formData.append(key, value, value.name);
+	else if (value instanceof Blob) formData.append(key, value);
+	else if (value !== void 0 && value !== null) formData.append(key, typeof value === "string" ? value : JSON.stringify(value));
+};
+const prepareMultipartBody = (body) => {
+	if (body instanceof FormData) return body;
+	const formData = new FormData();
+	if (body instanceof File) {
+		formData.append("file", body, body.name);
+		return formData;
+	}
+	if (body instanceof Blob) {
+		formData.append("file", body);
+		return formData;
+	}
+	if (typeof body === "object" && body !== null) {
+		for (const [key, value] of Object.entries(body)) appendFormDataValue(formData, key, value);
+		return formData;
+	}
+	throw new TypeError("Multipart routes require FormData, File, Blob, or an object body.");
+};
+const prepareClientRequestBody = (body, contentType) => {
+	if (body === void 0) return {
+		body: void 0,
+		contentType: void 0
+	};
+	if (contentType === "application/octet-stream") {
+		if (!isBinaryRequestBody(body)) throw new TypeError("Octet-stream routes require Blob, ArrayBuffer, ArrayBufferView, or ReadableStream bodies.");
+		return {
+			body,
+			contentType
+		};
+	}
+	if (body instanceof FormData || body instanceof File || body instanceof Blob) return {
+		body: prepareMultipartBody(body),
+		contentType: null
+	};
+	if (containsFileBody(body)) return {
+		body: prepareMultipartBody(body),
+		contentType: null
+	};
+	return {
+		body: JSON.stringify(body),
+		contentType: "application/json"
+	};
+};
+const createRequestInitWithBody = (method, headers, body, options = {}) => {
+	const requestInit = {
+		...options,
+		method,
+		headers,
+		body
+	};
+	if (body instanceof ReadableStream) requestInit.duplex = "half";
+	return requestInit;
+};
+//#endregion
+//#region ../fragno/dist/api/internal/route.js
+function getMountRoute(opts) {
+	const mountRoute = opts.mountRoute ?? `/api/${opts.name}`;
+	if (mountRoute.endsWith("/")) return mountRoute.slice(0, -1);
+	return mountRoute;
+}
+//#endregion
+//#region ../fragno/dist/api/error.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;
+	}
+	toResponse() {
+		return Response.json({
+			message: this.message,
+			issues: this.issues,
+			code: this.code
+		}, { status: this.status });
+	}
+};
+//#endregion
+//#region ../fragno/dist/api/request-input-context.js
+var RequestInputContext = class RequestInputContext {
+	#path;
+	#method;
+	#pathParams;
+	#searchParams;
+	#headers;
+	#body;
+	#request;
+	#parsedBody;
+	#inputSchema;
+	#shouldValidateInput;
+	constructor(config) {
+		this.#path = config.path;
+		this.#method = config.method;
+		this.#pathParams = config.pathParams;
+		this.#searchParams = config.searchParams;
+		this.#headers = config.headers;
+		this.#body = config.rawBody;
+		this.#request = config.request;
+		this.#parsedBody = config.parsedBody;
+		this.#inputSchema = config.inputSchema;
+		this.#shouldValidateInput = config.shouldValidateInput ?? true;
+	}
+	/**
+	* Create a RequestContext from a Request object for server-side handling
+	*/
+	static async fromRequest(config) {
+		return new RequestInputContext({
+			method: config.method,
+			path: config.path,
+			pathParams: config.state.pathParams,
+			searchParams: config.state.searchParams,
+			headers: config.state.headers,
+			request: config.request,
+			parsedBody: config.state.body,
+			rawBody: config.rawBody,
+			inputSchema: config.inputSchema,
+			shouldValidateInput: config.shouldValidateInput
+		});
+	}
+	/**
+	* Create a RequestContext for server-side rendering contexts (no Request object)
+	*/
+	static fromSSRContext(config) {
+		return new RequestInputContext({
+			method: config.method,
+			path: config.path,
+			pathParams: config.pathParams,
+			searchParams: config.searchParams ?? new URLSearchParams(),
+			headers: config.headers ?? new Headers(),
+			parsedBody: "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;
+	}
+	/**
+	* [Headers](https://developer.mozilla.org/en-US/docs/Web/API/Headers) object for request headers
+	* @remarks `Headers`
+	*/
+	get headers() {
+		return this.#headers;
+	}
+	get rawBody() {
+		return this.#body;
+	}
+	get request() {
+		return this.#request;
+	}
+	/**
+	* Access the request body as FormData.
+	*
+	* Use this method when handling file uploads or multipart form submissions.
+	* The request must have been sent with Content-Type: multipart/form-data.
+	*
+	* @throws Error if the request body is not FormData
+	*
+	* @example
+	* ```typescript
+	* defineRoute({
+	*   method: "POST",
+	*   path: "/upload",
+	*   async handler(ctx, res) {
+	*     const formData = ctx.formData();
+	*     const file = formData.get("file") as File;
+	*     const description = formData.get("description") as string;
+	*     // ... process file
+	*   }
+	* });
+	* ```
+	*/
+	formData() {
+		if (!(this.#parsedBody instanceof FormData)) throw new Error("Request body is not FormData. Ensure the request was sent with Content-Type: multipart/form-data.");
+		return this.#parsedBody;
+	}
+	/**
+	* Check if the request body is FormData.
+	*
+	* Useful for routes that accept both JSON and FormData payloads.
+	*
+	* @example
+	* ```typescript
+	* defineRoute({
+	*   method: "POST",
+	*   path: "/upload",
+	*   async handler(ctx, res) {
+	*     if (ctx.isFormData()) {
+	*       const formData = ctx.formData();
+	*       // handle file upload
+	*     } else {
+	*       const json = await ctx.input.valid();
+	*       // handle JSON payload
+	*     }
+	*   }
+	* });
+	* ```
+	*/
+	isFormData() {
+		return this.#parsedBody instanceof FormData;
+	}
+	/**
+	* Access the request body as a ReadableStream (application/octet-stream).
+	*
+	* @throws Error if the request body is not a ReadableStream
+	*/
+	bodyStream() {
+		if (!(this.#parsedBody instanceof ReadableStream)) throw new Error("Request body is not a ReadableStream. Ensure the request was sent with Content-Type: application/octet-stream.");
+		return this.#parsedBody;
+	}
+	/**
+	* Check if the request body is a ReadableStream.
+	*/
+	isBodyStream() {
+		return this.#parsedBody instanceof ReadableStream;
+	}
+	/**
+	* 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.#parsedBody;
+				return this.#validateInput();
+			}
+		};
+	}
+	async #validateInput() {
+		if (!this.#inputSchema) throw new Error("No input schema defined for this route");
+		if (this.#parsedBody instanceof FormData || this.#parsedBody instanceof Blob) throw new Error("Schema validation is only supported for JSON data, not FormData or Blob");
+		if (this.#parsedBody instanceof ReadableStream) throw new Error("Schema validation is only supported for JSON data, not FormData, Blob, or ReadableStream");
+		const result = await this.#inputSchema["~standard"].validate(this.#parsedBody);
+		if (result.issues) throw new FragnoApiValidationError("Validation failed", result.issues);
+		return result.value;
+	}
+};
+//#endregion
+//#region ../fragno/dist/api/internal/response-stream.js
+var ResponseStream = class {
+	#writer;
+	#encoder;
+	#abortSubscribers = [];
+	#responseReadable;
+	#aborted = false;
+	#abortPromise;
+	#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);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	async write(input) {
+		await this.writeRaw(JSON.stringify(input) + "\n");
+	}
+	sleep(ms) {
+		return new Promise((resolve) => {
+			setTimeout(resolve, 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.#abortPromise) {
+			this.#aborted = true;
+			this.#abortPromise = Promise.allSettled(this.#abortSubscribers.map(async (subscriber) => subscriber())).then((results) => {
+				const errors = [];
+				for (const result of results) if (result.status === "rejected") errors.push(result.reason);
+				if (errors.length > 0) throw new AggregateError(errors, "Failed to abort response stream.");
+			});
+		}
+		return this.#abortPromise;
+	}
+};
+//#endregion
+//#region ../fragno/dist/api/request-output-context.js
+/**
+* Utility function to merge headers from multiple sources.
+* Later headers override earlier ones.
+*/
+function mergeHeaders$1(...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 {
+	#runJsonStreamCallback;
+	constructor(options = {}) {
+		this.#runJsonStreamCallback = options.runJsonStreamCallback;
+	}
+	/**
+	* 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$1(initOrStatus.headers, headers);
+		return Response.json({
+			message,
+			code
+		}, {
+			status: initOrStatus.status,
+			headers: mergedHeaders
+		});
+	};
+	empty = (initOrStatus, headers) => {
+		const defaultHeaders = {};
+		if (typeof initOrStatus === "undefined") {
+			const mergedHeaders = mergeHeaders$1(defaultHeaders, headers);
+			return new Response(null, {
+				status: 201,
+				headers: mergedHeaders
+			});
+		}
+		if (typeof initOrStatus === "number") {
+			const mergedHeaders = mergeHeaders$1(defaultHeaders, headers);
+			return new Response(null, {
+				status: initOrStatus,
+				headers: mergedHeaders
+			});
+		}
+		const mergedHeaders = mergeHeaders$1(defaultHeaders, initOrStatus.headers, headers);
+		return new Response(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$1(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);
+		const runStreamCallback = 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 {
+				await stream.close();
+			}
+		};
+		try {
+			Promise.resolve(this.#runJsonStreamCallback ? this.#runJsonStreamCallback(runStreamCallback) : runStreamCallback()).catch(async (error) => {
+				console.error(error);
+				await stream.close();
+			});
+		} catch (error) {
+			console.error(error);
+			stream.close();
+		}
+		return new Response(stream.responseReadable, {
+			status: 200,
+			headers: mergeHeaders$1(defaultHeaders, headers)
+		});
+	};
+};
+var RequestOutputContext = class extends OutputContext {
+	#outputSchema;
+	constructor(outputSchema, options) {
+		super(options);
+		this.#outputSchema = outputSchema;
+	}
+};
+//#endregion
+//#region ../fragno/dist/api/route.js
+/**
+* Helper to resolve route factories into routes
+* @internal
+*/
+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 ../fragno/dist/util/content-type.js
+/**
+* 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
+	};
+}
+//#endregion
+//#region ../fragno/dist/util/nanostores.js
+/**
+* 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;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/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/.pnpm/nanostores@1.3.0/node_modules/nanostores/clean-stores/index.js
+const clean = Symbol("clean");
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/atom/index.js
+let listenerQueue = [];
+let lqIndex = 0;
+const QUEUE_ITEMS_PER_LISTENER = 4;
+const nanostoresGlobal = globalThis.nanostoresGlobal ||= { epoch: 0 };
+const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
+	let listeners = [];
+	let $atom = {
+		get() {
+			if (!$atom.lc) $atom.listen(() => {})();
+			return $atom.value;
+		},
+		init: initialValue,
+		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) {
+			nanostoresGlobal.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/.pnpm/nanostores@1.3.0/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;
+	};
+});
+const 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/.pnpm/nanostores@1.3.0/node_modules/nanostores/warn/index.js
+let warned = {};
+function warn(text) {
+	if (!warned[text]) {
+		warned[text] = true;
+		if (typeof console !== "undefined" && console.warn) {
+			console.groupCollapsed("Nano Stores: " + text);
+			console.trace("Source of deprecated call");
+			console.groupEnd();
+		}
+	}
+}
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/computed/index.js
+let computedStore = (stores, cb, batched) => {
+	if (!Array.isArray(stores)) stores = [stores];
+	let previousArgs;
+	let currentEpoch;
+	let set = () => {
+		if (currentEpoch === nanostoresGlobal.epoch) return;
+		currentEpoch = nanostoresGlobal.epoch;
+		let args = stores.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) {
+				warn("Use @nanostores/async for async computed. We will remove Promise support in computed() in Nano Stores 2.0");
+				value.then((asyncValue) => {
+					if (previousArgs === args) $computed.set(asyncValue);
+				});
+			} else {
+				$computed.set(value);
+				currentEpoch = nanostoresGlobal.epoch;
+			}
+		}
+	};
+	let $computed = /* @__PURE__ */ atom(void 0);
+	let get = $computed.get;
+	$computed.get = () => {
+		set();
+		return get();
+	};
+	let timer;
+	let run = batched ? () => {
+		clearTimeout(timer);
+		timer = setTimeout(set);
+	} : set;
+	onMount($computed, () => {
+		let unbinds = stores.map(($store) => $store.listen(run));
+		set();
+		return () => {
+			for (let unbind of unbinds) unbind();
+		};
+	});
+	return $computed;
+};
+const computed = /* @__NO_SIDE_EFFECTS__ */ (stores, fn) => computedStore(stores, fn);
+const batched = /* @__NO_SIDE_EFFECTS__ */ (stores, fn) => computedStore(stores, fn, true);
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.3.0/node_modules/nanostores/map/index.js
+const map = /* @__NO_SIDE_EFFECTS__ */ (initial = {}) => {
+	let $map = /* @__PURE__ */ 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 ../fragno/dist/util/ssr.js
+let stores = [];
+function addStore(store) {
+	stores.push(store);
+}
+//#endregion
+//#region ../fragno/dist/client/client-error.js
+/**
+* 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 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({
+			message: unknown.message,
+			code: unknown.code
+		}, status);
+	}
+};
+//#endregion
+//#region ../fragno/dist/client/internal/fetcher-merge.js
+/**
+* Merge two fetcher configurations, with user config taking precedence.
+* If user provides a custom function, it takes full precedence.
+* Otherwise, deep merge RequestInit options.
+*/
+function mergeFetcherConfigs(authorConfig, userConfig) {
+	if (userConfig?.type === "function") return userConfig;
+	if (!userConfig && authorConfig?.type === "function") return authorConfig;
+	const authorOpts = authorConfig?.type === "options" ? authorConfig.options : {};
+	const userOpts = userConfig?.type === "options" ? userConfig.options : {};
+	if (Object.keys(authorOpts).length === 0 && Object.keys(userOpts).length === 0) return;
+	return {
+		type: "options",
+		options: {
+			...authorOpts,
+			...userOpts,
+			headers: mergeHeaders(authorOpts.headers, userOpts.headers)
+		}
+	};
+}
+/**
+* Merge headers from author and user configs.
+* User headers override author headers.
+*/
+function mergeHeaders(author, user) {
+	if (!author && !user) return;
+	const merged = new Headers(author);
+	new Headers(user).forEach((value, key) => {
+		merged.set(key, value);
+	});
+	if (merged.keys().next().done) return;
+	return merged;
+}
+//#endregion
+//#region ../fragno/dist/client/internal/ndjson-streaming.js
+/**
+* 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 });
+	});
+}
+const parseNdjsonBuffer = (buffer, options) => {
+	const lines = buffer.split("\n");
+	const trailingBuffer = options.flush ? "" : lines.pop() ?? "";
+	for (let index = 0; index < lines.length; index += 1) {
+		const line = lines[index];
+		if (!line.trim()) continue;
+		let jsonObject;
+		try {
+			jsonObject = JSON.parse(line);
+		} catch (parseError) {
+			throw new FragnoClientUnknownApiError("Failed to parse NDJSON line", options.parseErrorStatus, { cause: parseError });
+		}
+		if (options.onItem(jsonObject) === false) {
+			const remainingLines = lines.slice(index + 1);
+			return {
+				stopped: true,
+				buffer: remainingLines.length > 0 ? `${remainingLines.join("\n")}\n${trailingBuffer}` : trailingBuffer
+			};
+		}
+	}
+	return {
+		stopped: false,
+		buffer: trailingBuffer
+	};
+};
+/**
+* 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 });
+			buffer = parseNdjsonBuffer(buffer, {
+				parseErrorStatus: 500,
+				onItem: (jsonObject) => {
+					items.push(jsonObject);
+					firstItem = jsonObject;
+					return false;
+				}
+			}).buffer;
+			if (firstItem !== null) {
+				const streamingPromise = continueStreaming(reader, decoder, buffer, items, store, abortSignal);
+				return {
+					firstItem,
+					items,
+					streamingPromise
+				};
+			}
+		}
+		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 FragnoClientFetchError || error instanceof FragnoClientUnknownApiError) {
+			store?.setError(error);
+			throw error;
+		}
+		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;
+	const appendItem = (jsonObject) => {
+		items.push(jsonObject);
+		store?.setData([...items]);
+	};
+	try {
+		while (true) {
+			buffer = parseNdjsonBuffer(buffer, {
+				parseErrorStatus: 400,
+				onItem: appendItem
+			}).buffer;
+			if (abortSignal?.aborted) throw new FragnoClientFetchAbortError("Operation was aborted");
+			const { done, value } = await (abortSignal ? Promise.race([reader.read(), createAbortPromise(abortSignal)]) : reader.read());
+			if (done) {
+				parseNdjsonBuffer(buffer, {
+					flush: true,
+					parseErrorStatus: 400,
+					onItem: appendItem
+				});
+				break;
+			}
+			buffer += decoder.decode(value, { stream: true });
+		}
+	} catch (error) {
+		if (error instanceof FragnoClientFetchError || error instanceof FragnoClientUnknownApiError) {
+			store?.setError(error);
+			throw error;
+		}
+		const clientError = new FragnoClientUnknownApiError("Unknown streaming error", 400, { cause: error });
+		store?.setError(clientError);
+		throw clientError;
+	} finally {
+		reader.releaseLock();
+	}
+	return items;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/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/.pnpm/@nanostores+query@0.3.4_nanostores@1.3.0/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 = ({ 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 = /* @__PURE__ */ 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 = /* @__PURE__ */ 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 [/* @__PURE__ */ atom(["" + keys, [keys]]), () => {}];
+		const keyParts = [];
+		const $key = /* @__PURE__ */ 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 = /* @__PURE__ */ 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;
+};
+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 ../fragno/dist/client/client.js
+/**
+* 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");
+async function schemaAllowsUndefined(schema) {
+	try {
+		return !(await schema["~standard"].validate(void 0)).issues;
+	} catch {
+		return false;
+	}
+}
+async function assertBodyProvided(body, inputSchema, errorMessage) {
+	if (typeof body !== "undefined" || inputSchema === void 0) return;
+	if (await schemaAllowsUndefined(inputSchema)) return;
+	throw new Error(errorMessage);
+}
+/**
+* Merge request headers from multiple sources.
+* Returns undefined if there are no headers to merge.
+* @internal
+*/
+function mergeRequestHeaders(...headerSources) {
+	const result = {};
+	let hasHeaders = false;
+	for (const source of headerSources) {
+		if (!source) continue;
+		if (source instanceof Headers) for (const [key, value] of source.entries()) {
+			result[key] = value;
+			hasHeaders = true;
+		}
+		else if (Array.isArray(source)) for (const [key, value] of source) {
+			result[key] = value;
+			hasHeaders = true;
+		}
+		else for (const [key, value] of Object.entries(source)) {
+			result[key] = value;
+			hasHeaders = true;
+		}
+	}
+	return hasHeaders ? result : void 0;
+}
+/**
+* @internal
+*/
+function buildUrl(config, params) {
+	const { baseUrl = "", mountRoute, path } = config;
+	const { pathParams, queryParams } = params ?? {};
+	const normalizedPathParams = unwrapObject(pathParams);
+	const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+	const filteredQueryParams = Object.fromEntries(Object.entries(normalizedQueryParams).filter(([_, value]) => value !== void 0));
+	const searchParams = new URLSearchParams(filteredQueryParams);
+	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>".
+* Atoms with undefined values are wrapped in computed atoms that map undefined to "" to avoid nanoquery treating the key as incomplete.
+* @param path
+* @param params
+* @returns
+* @internal
+*/
+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) => {
+		const value = queryParams[key];
+		if (value && typeof value === "object" && "get" in value) return /* @__PURE__ */ computed(value, (v) => v ?? "");
+		return value ?? "";
+	}) : [];
+	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;
+}
+/**
+* @internal
+*/
+function isGetHook(hook) {
+	return typeof hook === "object" && hook !== null && GET_HOOK_SYMBOL in hook && hook[GET_HOOK_SYMBOL] === true;
+}
+/**
+* @internal
+*/
+function isMutatorHook(hook) {
+	return typeof hook === "object" && hook !== null && MUTATOR_HOOK_SYMBOL in hook && hook[MUTATOR_HOOK_SYMBOL] === true;
+}
+/**
+* @internal
+*/
+function isStore(obj) {
+	return typeof obj === "object" && obj !== null && STORE_SYMBOL in obj && obj[STORE_SYMBOL] === true;
+}
+var ClientBuilder = class {
+	#publicConfig;
+	#fragmentConfig;
+	#fetcherConfig;
+	#cache = /* @__PURE__ */ new Map();
+	#createFetcherStore;
+	#createMutatorStore;
+	#invalidateKeys;
+	constructor(publicConfig, fragmentConfig) {
+		this.#publicConfig = publicConfig;
+		this.#fragmentConfig = fragmentConfig;
+		this.#fetcherConfig = publicConfig.fetcherConfig;
+		const [createFetcherStore, createMutatorStore, { invalidateKeys }] = nanoquery({
+			cache: this.#cache,
+			cacheLifetime: Infinity
+		});
+		this.#createFetcherStore = createFetcherStore;
+		this.#createMutatorStore = createMutatorStore;
+		this.#invalidateKeys = invalidateKeys;
+	}
+	get cacheEntries() {
+		return Object.fromEntries(this.#cache.entries());
+	}
+	createStore(input) {
+		if (typeof input === "function") return {
+			factory: input,
+			[STORE_SYMBOL]: true
+		};
+		return {
+			obj: input,
+			[STORE_SYMBOL]: true
+		};
+	}
+	/**
+	* Build a URL for a custom backend call using the configured baseUrl and mountRoute.
+	* Useful for fragment authors who need to make custom fetch calls.
+	*/
+	buildUrl(path, params) {
+		return buildUrl({
+			baseUrl: this.#publicConfig.baseUrl ?? "",
+			mountRoute: getMountRoute({
+				name: this.#fragmentConfig.name,
+				mountRoute: this.#publicConfig.mountRoute
+			}),
+			path
+		}, {
+			pathParams: params?.path,
+			queryParams: params?.query
+		});
+	}
+	/**
+	* Get the configured fetcher function for custom backend calls.
+	* Returns fetch with merged options applied.
+	*/
+	getFetcher() {
+		return {
+			fetcher: this.#getFetcher(),
+			defaultOptions: this.#getFetcherOptions()
+		};
+	}
+	#getFetcher() {
+		if (this.#fetcherConfig?.type === "function") return this.#fetcherConfig.fetcher;
+		return globalThis.fetch.bind(globalThis);
+	}
+	#getFetcherOptions() {
+		if (this.#fetcherConfig?.type === "options") return this.#fetcherConfig.options;
+	}
+	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 ${String(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({
+			name: this.#fragmentConfig.name,
+			mountRoute: this.#publicConfig.mountRoute
+		});
+		const fetcher = this.#getFetcher();
+		const fetcherOptions = this.#getFetcherOptions();
+		const useFetcherOnServer = this.#fetcherConfig?.type === "function" && this.#fetcherConfig.useOnServer;
+		async function callServerSideHandler(params) {
+			const { pathParams, queryParams } = params ?? {};
+			const normalizedPathParams = unwrapObject(pathParams);
+			const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+			const filteredQueryParams = Object.fromEntries(Object.entries(normalizedQueryParams).filter(([_, value]) => value !== void 0));
+			const searchParams = new URLSearchParams(filteredQueryParams);
+			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" && !useFetcherOnServer) return task(async () => callServerSideHandler({
+				pathParams,
+				queryParams
+			}));
+			const url = buildUrl({
+				baseUrl,
+				mountRoute,
+				path: route.path
+			}, {
+				pathParams,
+				queryParams
+			});
+			let response;
+			try {
+				response = fetcherOptions ? await fetcher(url, fetcherOptions) : await fetcher(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 () => {
+						const response = await executeQuery({
+							pathParams: path,
+							queryParams: query
+						});
+						const isStreaming = isStreamingResponse(response);
+						if (!isStreaming) return response.json();
+						if (typeof window === "undefined" && !useFetcherOnServer) {
+							if (response.body) await response.body.getReader().cancel();
+							return [];
+						}
+						if (isStreaming === "ndjson") {
+							const { items } = await handleNdjsonStreamingFirstItem(response, {
+								setData: (value) => {
+									store.mutate(value);
+								},
+								setError: (value) => {
+									store.set({
+										...store.get(),
+										error: value
+									});
+								}
+							});
+							return items;
+						}
+						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({
+			name: this.#fragmentConfig.name,
+			mountRoute: this.#publicConfig.mountRoute
+		});
+		const fetcher = this.#getFetcher();
+		const fetcherOptions = this.#getFetcherOptions();
+		const useFetcherOnServer = this.#fetcherConfig?.type === "function" && this.#fetcherConfig.useOnServer;
+		async function executeMutateQuery({ body, path, query }) {
+			if (typeof window === "undefined" && !useFetcherOnServer) 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 {
+				const preparedBody = prepareClientRequestBody(body, route.contentType);
+				const bodyHeaders = preparedBody.contentType === void 0 || preparedBody.contentType === null ? void 0 : { "Content-Type": preparedBody.contentType };
+				const headers = mergeRequestHeaders(fetcherOptions?.headers, bodyHeaders);
+				const requestOptions = createRequestInitWithBody(method, headers ?? {}, preparedBody.body, fetcherOptions);
+				response = await fetcher(url, requestOptions);
+			} 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;
+			await assertBodyProvided(body, route.inputSchema, "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 await 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;
+			await assertBodyProvided(body, route.inputSchema, "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 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 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));
+	}
+};
+/**
+* Create a client builder for fragments using the new fragment definition API.
+* This is the same as createClientBuilder but works with FragmentDefinition.
+*/
+function createClientBuilder(definition, publicConfig, routesOrFactories, authorFetcherConfig) {
+	const routes = resolveRouteFactories({
+		config: {},
+		deps: {},
+		services: {},
+		serviceDeps: {}
+	}, routesOrFactories);
+	const fragmentConfig = {
+		name: definition.name,
+		routes
+	};
+	const mountRoute = getMountRoute({
+		name: definition.name,
+		mountRoute: publicConfig.mountRoute
+	});
+	const mergedFetcherConfig = mergeFetcherConfigs(authorFetcherConfig, publicConfig.fetcherConfig);
+	return new ClientBuilder({
+		...publicConfig,
+		mountRoute,
+		fetcherConfig: mergedFetcherConfig
+	}, fragmentConfig);
+}
+//#endregion
+//#region src/definition.ts
+const mcpFragmentDefinition = defineFragment("mcp-fragment").extend((x) => x).providesBaseService(() => {}).build();
+//#endregion
+//#region src/mcp-types.ts
+const authConfigSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("none") }),
+	z.object({
+		type: z.literal("bearer"),
+		token: z.string().min(1)
+	}),
+	z.object({
+		type: z.literal("client_credentials"),
+		clientId: z.string().min(1),
+		clientSecret: z.string().min(1),
+		scopes: z.array(z.string()).optional()
+	}),
+	z.object({
+		type: z.literal("oauth"),
+		clientId: z.string().optional(),
+		clientSecret: z.string().optional(),
+		scopes: z.array(z.string()).optional()
+	})
+]);
+/** Slugs are URL path segments and OAuth state prefixes, so they exclude ':' and dot segments. */
+const mcpServerSlugSchema = z.string().regex(/^[a-z0-9][a-z0-9-]*$/);
+const createServerInputSchema = z.object({
+	slug: mcpServerSlugSchema,
+	name: z.string().optional(),
+	endpointUrl: z.url(),
+	auth: authConfigSchema.default({ type: "none" })
+});
+/** Replacement keeps the slug and creation time; everything else is supplied again. */
+const replaceServerConfigurationInputSchema = createServerInputSchema.omit({ slug: true });
+const toolCallInputSchema = z.object({
+	name: z.string().min(1),
+	arguments: z.record(z.string(), z.unknown()).optional(),
+	timeoutMs: z.number().int().positive().max(12e4).optional()
+});
+const tokenAuthInputSchema = z.object({ token: z.string().min(1) });
+const mcpCredentialsPresenceSchema = z.enum(["present", "missing"]).describe("Whether credentials are stored, not whether the server accepts them.");
+/** Sanitized auth state derived from stored configuration; it never proves live server access. */
+const mcpAuthStatusSchema = z.discriminatedUnion("mode", [
+	z.object({ mode: z.literal("none") }),
+	z.object({
+		mode: z.literal("bearer"),
+		credentials: mcpCredentialsPresenceSchema
+	}),
+	z.object({
+		mode: z.literal("client_credentials"),
+		credentials: mcpCredentialsPresenceSchema
+	}),
+	z.object({
+		mode: z.literal("oauth"),
+		state: z.enum([
+			"consent-required",
+			"consent-pending",
+			"authorized",
+			"expired"
+		]).describe("Expired means the access token expired and no refresh token is stored; pending means an unexpired authorization link exists.")
+	})
+]);
+/** The pending link embeds the callback state, so reading it needs server-create authority. */
+const mcpOAuthPendingSchema = z.object({ pending: z.object({
+	authorizationUrl: z.url(),
+	expiresAt: z.union([z.string(), z.date()])
+}).nullable().describe("The newest unexpired, unconsumed authorization link; any pending link completes it.") });
+/**
+* Mirrors the MCP protocol's tool definition, whose optional members are defined by the spec.
+* Loose so newer spec members, such as icons, survive the cache and the API.
+*/
+const mcpToolSchema = z.looseObject({
+	name: z.string(),
+	title: z.string().optional(),
+	description: z.string().optional(),
+	inputSchema: z.record(z.string(), z.unknown()),
+	outputSchema: z.record(z.string(), z.unknown()).optional(),
+	annotations: z.record(z.string(), z.unknown()).optional(),
+	_meta: z.record(z.string(), z.unknown()).optional()
+});
+/** Tool errors are results the model should see; transport and auth failures are route errors. */
+const mcpToolCallResultSchema = z.object({
+	isError: z.boolean(),
+	content: z.array(z.record(z.string(), z.unknown())),
+	/** Since MCP 2026-07-28 any JSON value; null when the tool returned none. */
+	structuredContent: z.unknown()
+});
+/** Query parameter carrying the OAuth callback URI for an MCP OAuth start request. */
+const MCP_OAUTH_REDIRECT_URI_QUERY_PARAMETER = "redirectUri";
+z.url().refine((value) => {
+	const protocol = new URL(value).protocol;
+	return protocol === "https:" || protocol === "http:";
+}, "MCP OAuth redirect URI must use HTTP or HTTPS");
+const oauthStartInputSchema = z.object({
+	scope: z.string().optional(),
+	clientId: z.string().min(1).optional(),
+	clientSecret: z.string().min(1).optional(),
+	discardTokens: z.boolean().default(false).describe("Drop stored tokens so status reports pending consent until this new consent completes.")
+});
+//#endregion
+//#region src/diagnostics.ts
+const serverConnectionCacheOutputSchema$1 = z.object({
+	protocolVersion: z.string().nullable().optional(),
+	serverInfo: z.unknown().nullable().optional(),
+	capabilities: z.unknown().nullable().optional(),
+	tools: z.array(mcpToolSchema).nullable().optional(),
+	updatedAt: z.union([z.string(), z.date()]).optional()
+});
+const serverOutputSchema$1 = z.object({
+	slug: z.string(),
+	name: z.string().nullable().optional(),
+	endpointUrl: z.string(),
+	authMode: z.string(),
+	cache: serverConnectionCacheOutputSchema$1.nullable().optional()
+});
+const refreshOutputSchema = z.object({
+	ok: z.boolean(),
+	tools: z.array(mcpToolSchema),
+	stage: z.enum(["auth", "list_tools"]).nullable(),
+	checkedAt: z.string(),
+	server: serverOutputSchema$1.omit({ cache: true }),
+	auth: z.object({
+		authenticated: z.boolean(),
+		mode: z.string(),
+		tokenPresent: z.boolean(),
+		expiresAt: z.union([z.string(), z.date()]).nullable(),
+		expired: z.boolean().nullable(),
+		scopes: z.object({
+			requested: z.array(z.string()).nullable(),
+			granted: z.array(z.string()).nullable(),
+			missing: z.array(z.string()).nullable(),
+			raw: z.string().nullable()
+		})
+	}),
+	live: z.object({
+		reachable: z.boolean(),
+		listToolsOk: z.boolean(),
+		toolCount: z.number().nullable(),
+		protocolVersion: z.string().nullable(),
+		serverInfo: z.unknown().nullable(),
+		capabilities: z.unknown().nullable()
+	}),
+	cache: z.object({
+		presentBeforeCheck: z.boolean(),
+		previousToolCount: z.number().nullable(),
+		updatedToolCount: z.number().nullable()
+	}),
+	error: z.object({
+		code: z.string(),
+		message: z.string()
+	}).nullable()
+});
+//#endregion
+//#region src/routes.ts
+const serverConnectionCacheOutputSchema = z.object({
+	protocolVersion: z.string().nullable().optional(),
+	serverInfo: z.unknown().nullable().optional(),
+	capabilities: z.unknown().nullable().optional(),
+	tools: z.array(mcpToolSchema).nullable().optional(),
+	updatedAt: z.union([z.string(), z.date()]).optional()
+});
+const serverOutputSchema = z.object({
+	slug: z.string(),
+	name: z.string().nullable().optional(),
+	endpointUrl: z.string(),
+	authMode: z.string(),
+	cache: serverConnectionCacheOutputSchema.nullable().optional()
+});
+//#endregion
+//#region src/index.ts
+const routes = [defineRoutes(mcpFragmentDefinition).create(({ services, defineRoute, config }) => {
+	return [
+		defineRoute({
+			method: "POST",
+			path: "/servers",
+			inputSchema: createServerInputSchema,
+			outputSchema: serverOutputSchema,
+			errorCodes: ["SERVER_EXISTS", "ENDPOINT_NOT_ALLOWED"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/servers",
+			outputSchema: z.object({ servers: z.array(serverOutputSchema) }),
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/servers/:slug",
+			outputSchema: serverOutputSchema,
+			errorCodes: ["SERVER_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "PUT",
+			path: "/servers/:slug/configuration",
+			inputSchema: replaceServerConfigurationInputSchema,
+			outputSchema: serverOutputSchema,
+			errorCodes: ["SERVER_NOT_FOUND", "ENDPOINT_NOT_ALLOWED"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "DELETE",
+			path: "/servers/:slug",
+			errorCodes: ["SERVER_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/servers/:slug/auth/status",
+			outputSchema: mcpAuthStatusSchema,
+			errorCodes: ["SERVER_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/servers/:slug/auth/pending",
+			outputSchema: mcpOAuthPendingSchema,
+			errorCodes: ["SERVER_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/servers/:slug/auth/token",
+			inputSchema: tokenAuthInputSchema,
+			outputSchema: mcpAuthStatusSchema,
+			errorCodes: ["SERVER_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/servers/:slug/auth/start",
+			inputSchema: oauthStartInputSchema,
+			outputSchema: z.object({
+				authorizationUrl: z.string(),
+				state: z.string()
+			}),
+			queryParameters: [MCP_OAUTH_REDIRECT_URI_QUERY_PARAMETER],
+			errorCodes: [
+				"INVALID_OAUTH_REDIRECT_URI",
+				"OAUTH_REDIRECT_URI_NOT_ALLOWED",
+				"SERVER_NOT_FOUND",
+				"OAUTH_ERROR"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/oauth/callback",
+			outputSchema: z.object({
+				authenticated: z.boolean(),
+				mode: z.string()
+			}),
+			errorCodes: [
+				"SERVER_NOT_FOUND",
+				"OAUTH_ERROR",
+				"INVALID_OAUTH_STATE"
+			],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "DELETE",
+			path: "/servers/:slug/auth",
+			outputSchema: mcpAuthStatusSchema,
+			errorCodes: ["SERVER_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/servers/:slug/refresh",
+			outputSchema: refreshOutputSchema,
+			errorCodes: ["SERVER_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/servers/:slug/tools/execute",
+			inputSchema: toolCallInputSchema,
+			outputSchema: mcpToolCallResultSchema,
+			errorCodes: ["SERVER_NOT_FOUND", "MCP_ERROR"],
+			handler: () => {}
+		})
+	];
+})];
+function createMcpFragment(config, fragnoConfig) {
+	return {};
+}
+function createMcpFragmentClients(fragnoConfig = {}) {
+	const builder = createClientBuilder(mcpFragmentDefinition, fragnoConfig, routes);
+	return {
+		useServers: builder.createHook("/servers"),
+		useServer: builder.createHook("/servers/:slug"),
+		createServer: builder.createMutator("POST", "/servers"),
+		refreshServer: builder.createMutator("POST", "/servers/:slug/refresh"),
+		callTool: builder.createMutator("POST", "/servers/:slug/tools/execute"),
+		setToken: builder.createMutator("POST", "/servers/:slug/auth/token"),
+		startOAuth: builder.createMutator("POST", "/servers/:slug/auth/start"),
+		deleteAuth: builder.createMutator("DELETE", "/servers/:slug/auth")
+	};
+}
+//#endregion
+export { isStore as a, isMutatorHook as i, createMcpFragmentClients as n, atom as o, isGetHook as r, isReadableAtom as s, createMcpFragment as t };
+
+//# sourceMappingURL=src-B6dHZXqB.js.map