@fragno-dev/cloudflare-fragment 0.0.1

package/dist/browser/schema-Bt-h9kGf.js

@@ -0,0 +1,2348 @@
+import { defineFragment, defineRoutes } from "@fragno-dev/core";
+import Cloudflare, { NotFoundError, toFile } from "cloudflare";
+import { z } from "zod";
+import { column, idColumn, referenceColumn, schema } from "@fragno-dev/db/schema";
+
+//#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/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/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;
+	}
+	get issues() {
+		return this.#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;
+	#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.#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,
+			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;
+	}
+	/**
+	* 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;
+	#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());
+		}
+	}
+};
+
+//#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 {
+	/**
+	* 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$1 = mergeHeaders$1(defaultHeaders, headers);
+			return new Response(null, {
+				status: 201,
+				headers: mergedHeaders$1
+			});
+		}
+		if (typeof initOrStatus === "number") {
+			const mergedHeaders$1 = mergeHeaders$1(defaultHeaders, headers);
+			return new Response(null, {
+				status: initOrStatus,
+				headers: mergedHeaders$1
+			});
+		}
+		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);
+		(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$1(defaultHeaders, headers)
+		});
+	};
+};
+var RequestOutputContext = class extends OutputContext {
+	#outputSchema;
+	constructor(outputSchema) {
+		super();
+		this.#outputSchema = outputSchema;
+	}
+};
+
+//#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.1.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.1.0/node_modules/nanostores/clean-stores/index.js
+let clean = Symbol("clean");
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.0/node_modules/nanostores/atom/index.js
+let listenerQueue = [];
+let lqIndex = 0;
+const QUEUE_ITEMS_PER_LISTENER = 4;
+let epoch = 0;
+const atom = /* @__NO_SIDE_EFFECTS__ */ (initialValue) => {
+	let listeners = [];
+	let $atom = {
+		get() {
+			if (!$atom.lc) $atom.listen(() => {})();
+			return $atom.value;
+		},
+		lc: 0,
+		listen(listener) {
+			$atom.lc = listeners.push(listener);
+			return () => {
+				for (let i = lqIndex + QUEUE_ITEMS_PER_LISTENER; i < listenerQueue.length;) if (listenerQueue[i] === listener) listenerQueue.splice(i, QUEUE_ITEMS_PER_LISTENER);
+				else i += QUEUE_ITEMS_PER_LISTENER;
+				let index = listeners.indexOf(listener);
+				if (~index) {
+					listeners.splice(index, 1);
+					if (!--$atom.lc) $atom.off();
+				}
+			};
+		},
+		notify(oldValue, changedKey) {
+			epoch++;
+			let runListenerQueue = !listenerQueue.length;
+			for (let listener of listeners) listenerQueue.push(listener, $atom.value, oldValue, changedKey);
+			if (runListenerQueue) {
+				for (lqIndex = 0; lqIndex < listenerQueue.length; lqIndex += QUEUE_ITEMS_PER_LISTENER) listenerQueue[lqIndex](listenerQueue[lqIndex + 1], listenerQueue[lqIndex + 2], listenerQueue[lqIndex + 3]);
+				listenerQueue.length = 0;
+			}
+		},
+		off() {},
+		set(newValue) {
+			let oldValue = $atom.value;
+			if (oldValue !== newValue) {
+				$atom.value = newValue;
+				$atom.notify(oldValue);
+			}
+		},
+		subscribe(listener) {
+			let unbind = $atom.listen(listener);
+			listener($atom.value);
+			return unbind;
+		},
+		value: initialValue
+	};
+	$atom[clean] = () => {
+		listeners = [];
+		$atom.lc = 0;
+		$atom.off();
+	};
+	return $atom;
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.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;
+	};
+});
+let STORE_UNMOUNT_DELAY = 1e3;
+let onMount = ($store, initialize) => {
+	let listener = (payload) => {
+		let destroy = initialize(payload);
+		if (destroy) $store.events[UNMOUNT].push(destroy);
+	};
+	return on($store, listener, MOUNT, (runListeners) => {
+		let originListen = $store.listen;
+		$store.listen = (...args) => {
+			if (!$store.lc && !$store.active) {
+				$store.active = true;
+				runListeners();
+			}
+			return originListen(...args);
+		};
+		let originOff = $store.off;
+		$store.events[UNMOUNT] = [];
+		$store.off = () => {
+			originOff();
+			setTimeout(() => {
+				if ($store.active && !$store.lc) {
+					$store.active = false;
+					for (let destroy of $store.events[UNMOUNT]) destroy();
+					$store.events[UNMOUNT] = [];
+				}
+			}, STORE_UNMOUNT_DELAY);
+		};
+		{
+			let originClean = $store[clean];
+			$store[clean] = () => {
+				for (let destroy of $store.events[UNMOUNT]) destroy();
+				$store.events[UNMOUNT] = [];
+				$store.active = false;
+				originClean();
+			};
+		}
+		return () => {
+			$store.listen = originListen;
+			$store.off = originOff;
+		};
+	});
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/nanostores@1.1.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 === epoch) return;
+		currentEpoch = 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) value.then((asyncValue) => {
+				if (previousArgs === args) $computed.set(asyncValue);
+			});
+			else {
+				$computed.set(value);
+				currentEpoch = 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.1.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 = [];
+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 ../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 });
+	});
+}
+/**
+* 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;
+}
+
+//#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.1.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");
+/**
+* Check if a value contains files that should be sent as FormData.
+* @internal
+*/
+function containsFiles(value) {
+	if (value instanceof File || value instanceof Blob) return true;
+	if (value instanceof FormData) return true;
+	if (typeof value === "object" && value !== null) return Object.values(value).some((v) => v instanceof File || v instanceof Blob || v instanceof FormData);
+	return false;
+}
+/**
+* Convert an object containing files to FormData.
+* Handles nested File/Blob values by appending them directly.
+* Other values are JSON-stringified.
+* @internal
+*/
+function toFormData(value) {
+	const formData = new FormData();
+	for (const [key, val] of Object.entries(value)) if (val instanceof File) formData.append(key, val, val.name);
+	else if (val instanceof Blob) formData.append(key, val);
+	else if (val !== void 0 && val !== null) formData.append(key, typeof val === "string" ? val : JSON.stringify(val));
+	return formData;
+}
+/**
+* Prepare request body and headers for sending.
+* Handles FormData (file uploads) vs JSON data.
+* @internal
+*/
+function prepareRequestBody(body, contentType) {
+	if (body === void 0) return { body: void 0 };
+	if (contentType === "application/octet-stream") {
+		if (body instanceof ReadableStream || body instanceof Blob || body instanceof File || body instanceof ArrayBuffer || body instanceof Uint8Array) return {
+			body,
+			headers: { "Content-Type": "application/octet-stream" }
+		};
+		throw new Error("Octet-stream routes only accept Blob, File, ArrayBuffer, Uint8Array, or ReadableStream bodies.");
+	}
+	if (body instanceof FormData) return { body };
+	if (body instanceof File) {
+		const formData = new FormData();
+		formData.append("file", body, body.name);
+		return { body: formData };
+	}
+	if (body instanceof Blob) {
+		const formData = new FormData();
+		formData.append("file", body);
+		return { body: formData };
+	}
+	if (typeof body === "object" && body !== null && containsFiles(body)) return { body: toFormData(body) };
+	return {
+		body: JSON.stringify(body),
+		headers: { "Content-Type": "application/json" }
+	};
+}
+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 });
+		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 ${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();
+		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") 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 () => {
+						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({
+			name: this.#fragmentConfig.name,
+			mountRoute: this.#publicConfig.mountRoute
+		});
+		const fetcher = this.#getFetcher();
+		const fetcherOptions = this.#getFetcherOptions();
+		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 {
+				const { body: preparedBody, headers: bodyHeaders } = prepareRequestBody(body, route.contentType);
+				const mergedHeaders = mergeRequestHeaders(fetcherOptions?.headers, bodyHeaders);
+				const requestOptions = {
+					...fetcherOptions,
+					method,
+					body: preparedBody,
+					...mergedHeaders ? { headers: mergedHeaders } : {}
+				};
+				if (preparedBody instanceof ReadableStream) requestOptions.duplex = "half";
+				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 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 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/deployment-tag.ts
+const DEFAULT_DEPLOYMENT_TAG_PREFIX = "fragno";
+const MAX_TAG_LENGTH = 63;
+const APP_TAG_SEGMENT = "app";
+const DEPLOYMENT_TAG_SEGMENT = "dep";
+const sanitizeCloudflareTag = (value) => {
+	return value.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").replace(/--+/g, "-");
+};
+const normalizeCloudflareDeploymentTagPrefix = (prefix) => {
+	const normalized = sanitizeCloudflareTag(prefix ?? DEFAULT_DEPLOYMENT_TAG_PREFIX);
+	if (!normalized) throw new Error("Cloudflare deployment tag prefix must contain at least one alphanumeric character.");
+	return normalized;
+};
+const trimTrailingHyphens = (value) => value.replace(/-+$/, "");
+const capCloudflareTagPrefix = (prefix, kind, normalizedId, label) => {
+	const maxPrefixLength = MAX_TAG_LENGTH - `-${kind}-`.length - normalizedId.length;
+	if (maxPrefixLength < 1) throw new Error(`Cloudflare ${label} tag '${normalizedId}' exceeds the ${MAX_TAG_LENGTH} character limit even with the shortest possible prefix.`);
+	const cappedPrefix = trimTrailingHyphens(prefix.slice(0, maxPrefixLength));
+	if (!cappedPrefix) throw new Error(`Cloudflare ${label} tag prefix must retain at least one alphanumeric character after capping.`);
+	return cappedPrefix;
+};
+const buildCloudflareScopedTag = (id, prefix, kind, label) => {
+	const normalizedPrefix = normalizeCloudflareDeploymentTagPrefix(prefix);
+	const normalizedId = sanitizeCloudflareTag(id);
+	if (!normalizedId) throw new Error(`Cloudflare ${label} id must contain at least one alphanumeric character.`);
+	return `${capCloudflareTagPrefix(normalizedPrefix, kind, normalizedId, label)}-${kind}-${normalizedId}`;
+};
+const readCloudflareScopedTagId = (tag, prefix, kind, label) => {
+	const normalizedTag = sanitizeCloudflareTag(tag);
+	const marker = `-${kind}-`;
+	const normalizedPrefix = normalizeCloudflareDeploymentTagPrefix(prefix);
+	let markerIndex = normalizedTag.indexOf(marker);
+	while (markerIndex >= 1) {
+		const normalizedId = normalizedTag.slice(markerIndex + marker.length);
+		if (normalizedId) try {
+			const expectedPrefix = capCloudflareTagPrefix(normalizedPrefix, kind, normalizedId, label);
+			if (normalizedTag.slice(0, markerIndex) === expectedPrefix) return normalizedId;
+		} catch {}
+		markerIndex = normalizedTag.indexOf(marker, markerIndex + 1);
+	}
+	return null;
+};
+const findCloudflareScopedTag = (tags, prefix, kind, label) => {
+	const marker = `-${kind}-`;
+	for (const tag of tags) {
+		const normalizedTag = sanitizeCloudflareTag(tag);
+		if (!normalizedTag.includes(marker)) continue;
+		if (readCloudflareScopedTagId(normalizedTag, prefix, kind, label) !== null) return normalizedTag;
+	}
+	return null;
+};
+const buildCloudflareAppTag = (appId, prefix) => {
+	return buildCloudflareScopedTag(appId, prefix, APP_TAG_SEGMENT, "app");
+};
+const buildCloudflareDeploymentTag = (deploymentId, prefix) => {
+	return buildCloudflareScopedTag(deploymentId, prefix, DEPLOYMENT_TAG_SEGMENT, "deployment");
+};
+const getCloudflareAppIdFromTag = (tag, prefix) => {
+	return readCloudflareScopedTagId(tag, prefix, APP_TAG_SEGMENT, "app");
+};
+const getCloudflareDeploymentIdFromTag = (tag, prefix) => {
+	return readCloudflareScopedTagId(tag, prefix, DEPLOYMENT_TAG_SEGMENT, "deployment");
+};
+const findCloudflareAppTag = (tags, prefix) => {
+	return findCloudflareScopedTag(tags, prefix, APP_TAG_SEGMENT, "app");
+};
+const findCloudflareDeploymentTag = (tags, prefix) => {
+	return findCloudflareScopedTag(tags, prefix, DEPLOYMENT_TAG_SEGMENT, "deployment");
+};
+
+//#endregion
+//#region src/cloudflare-api.ts
+const isRecord = (value) => typeof value === "object" && value !== null;
+const readNamespaceCandidate = (value) => {
+	if (typeof value !== "string") return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+};
+const unique = (items) => {
+	return Array.from(new Set(items));
+};
+const hasBindingDescriptor = (value) => {
+	return typeof value === "object" && value !== null && "binding" in value;
+};
+const resolveCloudflareDispatchNamespaceName = (dispatcher) => {
+	if (typeof dispatcher === "string") {
+		const namespace = readNamespaceCandidate(dispatcher);
+		if (namespace) return namespace;
+	} else if (hasBindingDescriptor(dispatcher)) {
+		const namespace = readNamespaceCandidate(dispatcher.namespace);
+		if (namespace) return namespace;
+	}
+	throw new Error("Cloudflare fragment requires a dispatch namespace name. Pass `dispatcher: \"my-namespace\"` or `dispatcher: { binding: env.DISPATCHER, namespace: \"my-namespace\" }`.");
+};
+const buildCloudflareScriptTags = (dynamicTags, staticTags = []) => {
+	const normalizedDynamicTags = Array.isArray(dynamicTags) ? dynamicTags : [dynamicTags];
+	return unique([...staticTags, ...normalizedDynamicTags].map(sanitizeCloudflareTag).filter((tag) => tag.length > 0));
+};
+const createCloudflareApiClient = ({ apiToken, fetchImplementation, maxRetries = 0 }) => {
+	return new Cloudflare({
+		apiToken,
+		fetch: fetchImplementation,
+		maxRetries
+	});
+};
+const listCloudflareScriptTags = async (client, input) => {
+	try {
+		const tags = await client.workersForPlatforms.dispatch.namespaces.scripts.tags.list(input.dispatchNamespace, input.scriptName, { account_id: input.accountId });
+		const results = [];
+		for await (const tag of tags) results.push(tag);
+		return results;
+	} catch (error) {
+		if (error instanceof NotFoundError) return [];
+		throw error;
+	}
+};
+const getCloudflareCurrentDeployment = async (client, input) => {
+	const deploymentTag = findCloudflareDeploymentTag(await listCloudflareScriptTags(client, input), input.deploymentTagPrefix);
+	if (deploymentTag === null) return null;
+	return {
+		deploymentTag,
+		deploymentId: getCloudflareDeploymentIdFromTag(deploymentTag, input.deploymentTagPrefix)
+	};
+};
+const getCloudflareScriptState = async (client, input) => {
+	try {
+		const script = await client.workersForPlatforms.dispatch.namespaces.scripts.get(input.dispatchNamespace, input.scriptName, { account_id: input.accountId });
+		return {
+			etag: script.script?.etag ?? null,
+			modifiedOn: script.modified_on ?? null
+		};
+	} catch (error) {
+		if (error instanceof NotFoundError) return null;
+		throw error;
+	}
+};
+const deployCloudflareWorker = async (client, input) => {
+	const moduleFile = await toFile(new TextEncoder().encode(input.moduleContent), input.entrypoint, { type: "application/javascript+module" });
+	const params = {
+		account_id: input.accountId,
+		metadata: {
+			main_module: input.entrypoint,
+			compatibility_date: input.compatibilityDate,
+			compatibility_flags: input.compatibilityFlags.length > 0 ? input.compatibilityFlags : void 0,
+			tags: input.tags && input.tags.length > 0 ? input.tags : void 0
+		},
+		files: [moduleFile]
+	};
+	return await client.workersForPlatforms.dispatch.namespaces.scripts.update(input.dispatchNamespace, input.scriptName, params, input.ifMatch ? { headers: { "If-Match": input.ifMatch } } : void 0);
+};
+const reconcileCloudflareWorkerDeployment = async (client, input) => {
+	const appTag = buildCloudflareAppTag(input.appId, input.deploymentTagPrefix);
+	const deploymentTag = buildCloudflareDeploymentTag(input.deploymentId, input.deploymentTagPrefix);
+	try {
+		return {
+			action: "uploaded",
+			deploymentTag,
+			response: await deployCloudflareWorker(client, {
+				accountId: input.accountId,
+				dispatchNamespace: input.dispatchNamespace,
+				scriptName: input.scriptName,
+				entrypoint: input.entrypoint,
+				moduleContent: input.moduleContent,
+				compatibilityDate: input.compatibilityDate,
+				compatibilityFlags: input.compatibilityFlags,
+				tags: buildCloudflareScriptTags([appTag, deploymentTag], input.scriptTags),
+				ifMatch: input.expectedLiveEtag
+			})
+		};
+	} catch (error) {
+		if (getCloudflareApiError(error)?.status !== 412) throw error;
+		const [currentDeployment, scriptState] = await Promise.all([getCloudflareCurrentDeployment(client, {
+			accountId: input.accountId,
+			dispatchNamespace: input.dispatchNamespace,
+			scriptName: input.scriptName,
+			deploymentTagPrefix: input.deploymentTagPrefix
+		}), getCloudflareScriptState(client, {
+			accountId: input.accountId,
+			dispatchNamespace: input.dispatchNamespace,
+			scriptName: input.scriptName
+		})]);
+		if (currentDeployment?.deploymentTag === deploymentTag) return {
+			action: "already-deployed",
+			deploymentTag,
+			currentDeploymentTag: currentDeployment.deploymentTag,
+			currentDeploymentId: currentDeployment.deploymentId,
+			currentEtag: scriptState?.etag ?? null,
+			currentModifiedOn: scriptState?.modifiedOn ?? null
+		};
+		if (currentDeployment !== null) return {
+			action: "superseded",
+			deploymentTag,
+			currentDeploymentTag: currentDeployment.deploymentTag,
+			currentDeploymentId: currentDeployment.deploymentId,
+			currentEtag: scriptState?.etag ?? null,
+			currentModifiedOn: scriptState?.modifiedOn ?? null
+		};
+		throw error;
+	}
+};
+const getCloudflareApiError = (error) => {
+	if (!(error instanceof Cloudflare.APIError)) return null;
+	const [firstError] = error.errors;
+	return {
+		status: error.status,
+		code: firstError?.code === void 0 || firstError?.code === null ? error.name : String(firstError.code),
+		message: firstError?.message ?? error.message,
+		details: isRecord(error.error) ? error.error : void 0
+	};
+};
+
+//#endregion
+//#region src/contracts.ts
+const SUPPORTED_DEPLOYMENT_FORMAT = "esmodule";
+const DEFAULT_DEPLOYMENT_ENTRYPOINT = "index.mjs";
+const cloudflareCompatibilityDateSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "compatibilityDate must use YYYY-MM-DD.");
+const cloudflareDeploymentStatusSchema = z.enum([
+	"queued",
+	"deploying",
+	"succeeded",
+	"failed"
+]);
+const cloudflareDeployScriptSchema = z.object({
+	type: z.enum([SUPPORTED_DEPLOYMENT_FORMAT]).default(SUPPORTED_DEPLOYMENT_FORMAT),
+	entrypoint: z.string().trim().min(1).default(DEFAULT_DEPLOYMENT_ENTRYPOINT),
+	content: z.string()
+});
+const cloudflareDeployRequestSchema = z.object({
+	script: cloudflareDeployScriptSchema,
+	compatibilityDate: cloudflareCompatibilityDateSchema.optional(),
+	compatibilityFlags: z.array(z.string().min(1)).optional()
+});
+const cloudflareTimestampSchema = z.string().datetime({ offset: true });
+const cloudflareProviderSummarySchema = z.object({
+	etag: z.string().nullable(),
+	modifiedOn: cloudflareTimestampSchema.nullable()
+});
+const cloudflareDeploymentSummarySchema = z.object({
+	id: z.string(),
+	appId: z.string(),
+	scriptName: z.string(),
+	status: cloudflareDeploymentStatusSchema,
+	format: z.literal(SUPPORTED_DEPLOYMENT_FORMAT),
+	entrypoint: z.string(),
+	sourceByteLength: z.number().int().nonnegative(),
+	compatibilityDate: cloudflareCompatibilityDateSchema,
+	compatibilityFlags: z.array(z.string()),
+	attemptCount: z.number().int().nonnegative(),
+	queuedAt: cloudflareTimestampSchema,
+	startedAt: cloudflareTimestampSchema.nullable(),
+	completedAt: cloudflareTimestampSchema.nullable(),
+	errorCode: z.string().nullable(),
+	errorMessage: z.string().nullable(),
+	cloudflare: cloudflareProviderSummarySchema.nullable(),
+	createdAt: cloudflareTimestampSchema,
+	updatedAt: cloudflareTimestampSchema
+});
+const cloudflareDeploymentDetailSchema = cloudflareDeploymentSummarySchema.extend({ sourceCode: z.string() });
+const cloudflareAppSummarySchema = z.object({
+	id: z.string(),
+	scriptName: z.string(),
+	latestDeployment: cloudflareDeploymentSummarySchema.nullable(),
+	createdAt: cloudflareTimestampSchema,
+	updatedAt: cloudflareTimestampSchema
+});
+const cloudflareAppStateSchema = cloudflareAppSummarySchema.extend({
+	liveDeployment: cloudflareDeploymentSummarySchema.nullable(),
+	liveDeploymentError: z.string().nullable(),
+	deployments: z.array(cloudflareDeploymentSummarySchema)
+});
+const cloudflareAppListSchema = z.object({ apps: z.array(cloudflareAppSummarySchema) });
+const cloudflareDeploymentListSchema = z.object({ deployments: z.array(cloudflareDeploymentSummarySchema) });
+
+//#endregion
+//#region src/script-name.ts
+const DEFAULT_SCRIPT_NAME_SEPARATOR = "-";
+const DEFAULT_MAX_SCRIPT_NAME_LENGTH = 63;
+const normalizeSeparator = (value) => {
+	const cleaned = (value ?? DEFAULT_SCRIPT_NAME_SEPARATOR).replace(/[^a-z0-9-]+/gi, "-");
+	return cleaned.length > 0 ? cleaned : DEFAULT_SCRIPT_NAME_SEPARATOR;
+};
+const sanitizeSegment = (value) => {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+/, "").replace(/-+$/, "").replace(/-{2,}/g, "-");
+};
+const hashString = (value) => {
+	let hash = 2166136261;
+	for (const char of value) {
+		hash ^= char.charCodeAt(0);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+};
+const resolveCloudflareScriptName = (appId, config = {}) => {
+	const separator = normalizeSeparator(config.scriptNameSeparator);
+	const maxLength = Math.max(16, config.maxScriptNameLength ?? DEFAULT_MAX_SCRIPT_NAME_LENGTH);
+	const base = [
+		config.scriptNamePrefix,
+		appId,
+		config.scriptNameSuffix
+	].map((segment) => sanitizeSegment(segment ?? "")).filter(Boolean).join(separator) || "app";
+	if (base.length <= maxLength) return base;
+	const hash = hashString(base);
+	const budget = Math.max(1, maxLength - hash.length - separator.length);
+	return `${base.slice(0, budget).replace(/-+$/, "") || "app"}${separator}${hash}`.slice(0, maxLength).replace(/-+$/, "");
+};
+
+//#endregion
+//#region src/definition.ts
+const cloudflareFragmentDefinition = defineFragment("cloudflare-fragment").extend((x) => x).withDependencies(() => {}).providesService("cloudflare", ({ deps }) => ({ getClient: () => deps.cloudflare })).providesBaseService(() => {}).build();
+
+//#endregion
+//#region src/routes.ts
+const cloudflareRoutesFactory = defineRoutes(cloudflareFragmentDefinition).create(({ services, defineRoute }) => {
+	return [
+		defineRoute({
+			method: "GET",
+			path: "/apps",
+			outputSchema: cloudflareAppListSchema,
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "POST",
+			path: "/apps/:appId/deployments",
+			inputSchema: cloudflareDeployRequestSchema,
+			outputSchema: cloudflareDeploymentSummarySchema,
+			errorCodes: ["INVALID_DEPLOY_INPUT", "UNSUPPORTED_DEPLOY_REQUEST"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/apps/:appId/deployments",
+			outputSchema: cloudflareDeploymentListSchema,
+			errorCodes: ["APP_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/deployments/:deploymentId",
+			outputSchema: cloudflareDeploymentDetailSchema,
+			errorCodes: ["DEPLOYMENT_NOT_FOUND"],
+			handler: () => {}
+		}),
+		defineRoute({
+			method: "GET",
+			path: "/apps/:appId",
+			outputSchema: cloudflareAppStateSchema,
+			errorCodes: ["APP_NOT_FOUND"],
+			handler: () => {}
+		})
+	];
+});
+
+//#endregion
+//#region src/schema.ts
+const cloudflareSchema = schema("cloudflare-fragment", (s) => {
+	return s.addTable("app", (t) => {
+		return t.addColumn("id", idColumn()).addColumn("scriptName", column("string")).addColumn("liveDeploymentId", column("string").nullable()).addColumn("liveCloudflareEtag", column("string").nullable()).addColumn("firstDeploymentLeaseId", column("string").nullable()).addColumn("createdAt", column("timestamp").defaultTo((b) => b.now())).addColumn("updatedAt", column("timestamp").defaultTo((b) => b.now())).createIndex("idx_app_scriptName", ["scriptName"], { unique: true });
+	}).addTable("deployment", (t) => {
+		return t.addColumn("id", idColumn()).addColumn("appId", referenceColumn()).addColumn("status", column("string")).addColumn("format", column("string")).addColumn("entrypoint", column("string")).addColumn("scriptName", column("string")).addColumn("sourceCode", column("string")).addColumn("sourceByteLength", column("integer")).addColumn("compatibilityDate", column("string")).addColumn("compatibilityFlags", column("json")).addColumn("attemptCount", column("integer").defaultTo(0)).addColumn("startedAt", column("timestamp").nullable()).addColumn("completedAt", column("timestamp").nullable()).addColumn("errorCode", column("string").nullable()).addColumn("errorMessage", column("string").nullable()).addColumn("cloudflareEtag", column("string").nullable()).addColumn("cloudflareModifiedOn", column("string").nullable()).addColumn("cloudflareResponse", column("json").nullable()).addColumn("createdAt", column("timestamp").defaultTo((b) => b.now())).addColumn("updatedAt", column("timestamp").defaultTo((b) => b.now())).createIndex("idx_deployment_app_createdAt", ["appId", "createdAt"]).createIndex("idx_deployment_status_createdAt", ["status", "createdAt"]);
+	}).addReference("app", {
+		type: "one",
+		from: {
+			table: "deployment",
+			column: "appId"
+		},
+		to: {
+			table: "app",
+			column: "id"
+		}
+	});
+});
+
+//#endregion
+export { findCloudflareAppTag as A, atom as B, getCloudflareScriptState as C, DEFAULT_DEPLOYMENT_TAG_PREFIX as D, resolveCloudflareDispatchNamespaceName as E, sanitizeCloudflareTag as F, createClientBuilder as I, isGetHook as L, getCloudflareAppIdFromTag as M, getCloudflareDeploymentIdFromTag as N, buildCloudflareAppTag as O, normalizeCloudflareDeploymentTagPrefix as P, isMutatorHook as R, getCloudflareCurrentDeployment as S, reconcileCloudflareWorkerDeployment as T, isReadableAtom as V, cloudflareDeploymentSummarySchema as _, DEFAULT_SCRIPT_NAME_SEPARATOR as a, deployCloudflareWorker as b, SUPPORTED_DEPLOYMENT_FORMAT as c, cloudflareAppSummarySchema as d, cloudflareDeployRequestSchema as f, cloudflareDeploymentStatusSchema as g, cloudflareDeploymentListSchema as h, DEFAULT_MAX_SCRIPT_NAME_LENGTH as i, findCloudflareDeploymentTag as j, buildCloudflareDeploymentTag as k, cloudflareAppListSchema as l, cloudflareDeploymentDetailSchema as m, cloudflareRoutesFactory as n, resolveCloudflareScriptName as o, cloudflareDeployScriptSchema as p, cloudflareFragmentDefinition as r, DEFAULT_DEPLOYMENT_ENTRYPOINT as s, cloudflareSchema as t, cloudflareAppStateSchema as u, buildCloudflareScriptTags as v, listCloudflareScriptTags as w, getCloudflareApiError as x, createCloudflareApiClient as y, isStore as z };
+//# sourceMappingURL=schema-Bt-h9kGf.js.map