@fragno-dev/core 0.0.1

package/dist/client-DWjxKDnE.js

@@ -0,0 +1,703 @@
+import { RequestInputContext, RequestOutputContext, getMountRoute, resolveRouteFactories } from "./route-Bp6eByhz.js";
+import { SSR_ENABLED, addStore, getInitialData } from "./ssr-tJHqcNSw.js";
+import { task } from "nanostores";
+import { nanoquery } from "@nanostores/query";
+
+//#region src/api/internal/path.ts
+/**
+* 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 src/client/client-error.ts
+/**
+* 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 src/util/content-type.ts
+/**
+* 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 src/client/internal/ndjson-streaming.ts
+/**
+* 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 src/util/nanostores.ts
+/**
+* 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 src/client/client.ts
+/**
+* Symbols used to identify hook types
+*/
+const GET_HOOK_SYMBOL = Symbol("fragno-get-hook");
+const MUTATOR_HOOK_SYMBOL = Symbol("fragno-mutator-hook");
+const STORE_SYMBOL = Symbol("fragno-store");
+function buildUrl(config, params) {
+	const { baseUrl = "", mountRoute, path } = config;
+	const { pathParams, queryParams } = params ?? {};
+	const normalizedPathParams = unwrapObject(pathParams);
+	const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+	const searchParams = new URLSearchParams(normalizedQueryParams);
+	const builtPath = buildPath(path, normalizedPathParams ?? {});
+	const search = searchParams.toString() ? `?${searchParams.toString()}` : "";
+	return `${baseUrl}${mountRoute}${builtPath}${search}`;
+}
+/**
+* This method returns an array, which can be passed directly to nanostores.
+*
+* The returned array is always: path, pathParams (In order they appear in the path), queryParams (In alphabetical order)
+* Missing pathParams are replaced with "<missing>".
+* @param path
+* @param params
+* @returns
+*/
+function getCacheKey(method, path, params) {
+	if (!params) return [method, path];
+	const { pathParams, queryParams } = params;
+	const pathParamValues = extractPathParams(path).map((name) => pathParams?.[name] ?? "<missing>");
+	const queryParamValues = queryParams ? Object.keys(queryParams).sort().map((key) => queryParams[key]) : [];
+	return [
+		method,
+		path,
+		...pathParamValues,
+		...queryParamValues
+	];
+}
+function isStreamingResponse(response) {
+	const contentType = parseContentType(response.headers.get("content-type"));
+	if (!contentType) return false;
+	if (!(response.headers.get("transfer-encoding") === "chunked")) return false;
+	if (contentType.subtype === "octet-stream") return "octet-stream";
+	if (contentType.subtype === "x-ndjson") return "ndjson";
+	return false;
+}
+function isGetHook(hook) {
+	return typeof hook === "object" && hook !== null && GET_HOOK_SYMBOL in hook && hook[GET_HOOK_SYMBOL] === true;
+}
+function isMutatorHook(hook) {
+	return typeof hook === "object" && hook !== null && MUTATOR_HOOK_SYMBOL in hook && hook[MUTATOR_HOOK_SYMBOL] === true;
+}
+function isStore(obj) {
+	return typeof obj === "object" && obj !== null && STORE_SYMBOL in obj && obj[STORE_SYMBOL] === true;
+}
+var ClientBuilder = class {
+	#publicConfig;
+	#fragmentConfig;
+	#cache = /* @__PURE__ */ new Map();
+	#createFetcherStore;
+	#createMutatorStore;
+	#invalidateKeys;
+	constructor(publicConfig, fragmentConfig) {
+		this.#publicConfig = publicConfig;
+		this.#fragmentConfig = fragmentConfig;
+		const [createFetcherStore, createMutatorStore, { invalidateKeys }] = nanoquery({ cache: this.#cache });
+		this.#createFetcherStore = createFetcherStore;
+		this.#createMutatorStore = createMutatorStore;
+		this.#invalidateKeys = invalidateKeys;
+	}
+	get cacheEntries() {
+		return Object.fromEntries(this.#cache.entries());
+	}
+	createStore(obj) {
+		return {
+			obj,
+			[STORE_SYMBOL]: true
+		};
+	}
+	createHook(path, options) {
+		const route = this.#fragmentConfig.routes.find((r) => r.path === path && r.method === "GET" && r.outputSchema !== void 0);
+		if (!route) throw new Error(`Route '${path}' not found or is not a GET route with an output schema.`);
+		return this.#createRouteQueryHook(route, options);
+	}
+	createMutator(method, path, onInvalidate) {
+		const route = this.#fragmentConfig.routes.find((r) => r.method !== "GET" && r.path === path && r.method === method);
+		if (!route) throw new Error(`Route '${path}' not found or is a GET route with an input and output schema.`);
+		return this.#createRouteQueryMutator(route, onInvalidate);
+	}
+	#createRouteQueryHook(route, options = {}) {
+		if (route.method !== "GET") throw new Error(`Only GET routes are supported for hooks. Route '${route.path}' is a ${route.method} route.`);
+		if (!route.outputSchema) throw new Error(`Output schema is required for GET routes. Route '${route.path}' has no output schema.`);
+		const baseUrl = this.#publicConfig.baseUrl ?? "";
+		const mountRoute = getMountRoute(this.#fragmentConfig);
+		async function callServerSideHandler(params) {
+			const { pathParams, queryParams } = params ?? {};
+			const normalizedPathParams = unwrapObject(pathParams);
+			const normalizedQueryParams = unwrapObject(queryParams) ?? {};
+			const searchParams = new URLSearchParams(normalizedQueryParams);
+			return await route.handler(RequestInputContext.fromSSRContext({
+				method: route.method,
+				path: route.path,
+				pathParams: normalizedPathParams,
+				searchParams
+			}), new RequestOutputContext(route.outputSchema));
+		}
+		async function executeQuery(params) {
+			const { pathParams, queryParams } = params ?? {};
+			if (typeof window === "undefined") return task(async () => callServerSideHandler({
+				pathParams,
+				queryParams
+			}));
+			const url = buildUrl({
+				baseUrl,
+				mountRoute,
+				path: route.path
+			}, {
+				pathParams,
+				queryParams
+			});
+			let response;
+			try {
+				response = await fetch(url);
+			} catch (error) {
+				throw FragnoClientFetchError.fromUnknownFetchError(error);
+			}
+			if (!response.ok) throw await FragnoClientApiError.fromResponse(response);
+			return response;
+		}
+		return {
+			route,
+			store: (args) => {
+				const { path, query } = args ?? {};
+				const key = getCacheKey(route.method, route.path, {
+					pathParams: path,
+					queryParams: query
+				});
+				const store = this.#createFetcherStore(key, {
+					fetcher: async () => {
+						if (SSR_ENABLED) {
+							const initialData = getInitialData(key.map((d) => typeof d === "string" ? d : d.get()).join(""));
+							if (initialData) return initialData;
+						}
+						const response = await executeQuery({
+							pathParams: path,
+							queryParams: query
+						});
+						const isStreaming = isStreamingResponse(response);
+						if (!isStreaming) return response.json();
+						if (typeof window === "undefined") return [];
+						if (isStreaming === "ndjson") {
+							const { firstItem } = await handleNdjsonStreamingFirstItem(response, {
+								setData: (value) => {
+									store.set({
+										...store.get(),
+										loading: !(Array.isArray(value) && value.length > 0),
+										data: value
+									});
+								},
+								setError: (value) => {
+									store.set({
+										...store.get(),
+										error: value
+									});
+								}
+							});
+							return [firstItem];
+						}
+						if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+						throw new Error("Unreachable");
+					},
+					onErrorRetry: options?.onErrorRetry,
+					dedupeTime: Infinity
+				});
+				if (typeof window === "undefined") addStore(store);
+				return store;
+			},
+			query: async (args) => {
+				const { path, query } = args ?? {};
+				const response = await executeQuery({
+					pathParams: path,
+					queryParams: query
+				});
+				const isStreaming = isStreamingResponse(response);
+				if (!isStreaming) return await response.json();
+				if (isStreaming === "ndjson") {
+					const { streamingPromise } = await handleNdjsonStreamingFirstItem(response);
+					return await streamingPromise;
+				}
+				if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+				throw new Error("Unreachable");
+			},
+			[GET_HOOK_SYMBOL]: true
+		};
+	}
+	#createRouteQueryMutator(route, onInvalidate = (invalidate, params) => invalidate("GET", route.path, params)) {
+		const method = route.method;
+		const baseUrl = this.#publicConfig.baseUrl ?? "";
+		const mountRoute = getMountRoute(this.#fragmentConfig);
+		async function executeMutateQuery({ body, path, query }) {
+			if (typeof window === "undefined") return task(async () => route.handler(RequestInputContext.fromSSRContext({
+				inputSchema: route.inputSchema,
+				method,
+				path: route.path,
+				pathParams: path ?? {},
+				searchParams: new URLSearchParams(query),
+				body
+			}), new RequestOutputContext(route.outputSchema)));
+			const url = buildUrl({
+				baseUrl,
+				mountRoute,
+				path: route.path
+			}, {
+				pathParams: path,
+				queryParams: query
+			});
+			let response;
+			try {
+				response = await fetch(url, {
+					method,
+					body: body !== void 0 ? JSON.stringify(body) : void 0
+				});
+			} catch (error) {
+				throw FragnoClientFetchError.fromUnknownFetchError(error);
+			}
+			if (!response.ok) throw await FragnoClientApiError.fromResponse(response);
+			return response;
+		}
+		const mutatorStore = this.#createMutatorStore(async ({ data }) => {
+			if (typeof window === "undefined") {}
+			const { body, path, query } = data;
+			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required.");
+			const response = await executeMutateQuery({
+				body,
+				path,
+				query
+			});
+			onInvalidate(this.#invalidate.bind(this), {
+				pathParams: path ?? {},
+				queryParams: query
+			});
+			if (response.status === 201 || response.status === 204) return;
+			const isStreaming = isStreamingResponse(response);
+			if (!isStreaming) return response.json();
+			if (typeof window === "undefined") return [];
+			if (isStreaming === "ndjson") {
+				const { firstItem } = await handleNdjsonStreamingFirstItem(response, {
+					setData: (value) => {
+						mutatorStore.set({
+							...mutatorStore.get(),
+							loading: !(Array.isArray(value) && value.length > 0),
+							data: value
+						});
+					},
+					setError: (value) => {
+						mutatorStore.set({
+							...mutatorStore.get(),
+							error: value
+						});
+					}
+				});
+				return [firstItem];
+			}
+			if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported.");
+			throw new Error("Unreachable");
+		}, { onError: (error) => {
+			console.error("Error in mutatorStore", error);
+		} });
+		const mutateQuery = (async (data) => {
+			const { body, path, query } = data;
+			if (typeof body === "undefined" && route.inputSchema !== void 0) throw new Error("Body is required for mutateQuery");
+			const response = await executeMutateQuery({
+				body,
+				path,
+				query
+			});
+			if (response.status === 201 || response.status === 204) return;
+			const isStreaming = isStreamingResponse(response);
+			if (!isStreaming) return response.json();
+			if (isStreaming === "ndjson") {
+				const { streamingPromise } = await handleNdjsonStreamingFirstItem(response);
+				return await streamingPromise;
+			}
+			if (isStreaming === "octet-stream") throw new Error("Octet-stream streaming is not supported for mutations");
+			throw new Error("Unreachable");
+		});
+		return {
+			route,
+			mutateQuery,
+			mutatorStore,
+			[MUTATOR_HOOK_SYMBOL]: true
+		};
+	}
+	#invalidate(method, path, params) {
+		const prefix = getCacheKey(method, path, {
+			pathParams: params?.pathParams,
+			queryParams: params?.queryParams
+		}).map((k) => typeof k === "string" ? k : k.get()).join("");
+		this.#invalidateKeys((key) => key.startsWith(prefix));
+	}
+};
+function createClientBuilder(fragmentDefinition, publicConfig, routesOrFactories) {
+	const definition = fragmentDefinition.definition;
+	const routes = resolveRouteFactories({
+		config: {},
+		deps: {},
+		services: {}
+	}, routesOrFactories);
+	const fragmentConfig = {
+		name: definition.name,
+		routes
+	};
+	const mountRoute = publicConfig.mountRoute ?? `/${definition.name}`;
+	const fullPublicConfig = {
+		...publicConfig,
+		mountRoute
+	};
+	return new ClientBuilder(fullPublicConfig, fragmentConfig);
+}
+
+//#endregion
+export { ClientBuilder, FragnoClientApiError, FragnoClientError, FragnoClientFetchAbortError, FragnoClientFetchError, FragnoClientFetchNetworkError, FragnoClientUnknownApiError, buildUrl, createClientBuilder, getCacheKey, isGetHook, isMutatorHook, isReadableAtom, isStore };
+//# sourceMappingURL=client-DWjxKDnE.js.map