@mearie/core 0.0.1-next.3 → 0.0.1-next.4

package/dist/index.cjs

@@ -1,65 +1,465 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+
+//#region src/errors.ts
+/**
+*
+*/
+var GraphQLError = class GraphQLError extends Error {
+	path;
+	locations;
+	extensions;
+	constructor(message, options) {
+		super(message, { cause: options?.cause });
+		this.name = "GraphQLError";
+		this.path = options?.path;
+		this.locations = options?.locations;
+		this.extensions = options?.extensions;
+		Object.setPrototypeOf(this, GraphQLError.prototype);
+	}
+	toJSON() {
+		const json = { message: this.message };
+		if (this.path) json.path = this.path;
+		if (this.locations) json.locations = this.locations;
+		if (this.extensions) json.extensions = this.extensions;
+		return json;
 	}
-	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
+/**
+*
+*/
+var ExchangeError = class ExchangeError extends Error {
+	exchangeName;
+	extensions;
+	constructor(message, options) {
+		super(message, { cause: options.cause });
+		this.name = "ExchangeError";
+		this.exchangeName = options.exchangeName;
+		this.extensions = options.extensions;
+		Object.setPrototypeOf(this, ExchangeError.prototype);
+	}
+	toJSON() {
+		const json = {
+			message: this.message,
+			exchangeName: this.exchangeName
+		};
+		if (this.extensions !== void 0) json.extensions = this.extensions;
+		return json;
+	}
+};
+/**
+*
+*/
+var AggregatedError = class AggregatedError extends AggregateError {
+	constructor(errors, message = `${errors.length} error(s) occurred`) {
+		super([...errors], message);
+		this.name = "AggregatedError";
+		Object.setPrototypeOf(this, AggregatedError.prototype);
+	}
+	toJSON() {
+		return {
+			message: this.message,
+			errors: this.errors.map((error) => error.toJSON())
+		};
+	}
+};
+const isGraphQLError = (error) => {
+	return error instanceof GraphQLError;
+};
+function isExchangeError(error, exchangeName) {
+	if (!(error instanceof ExchangeError)) return false;
+	if (exchangeName !== void 0) return error.exchangeName === exchangeName;
+	return true;
+}
+const isAggregatedError = (error) => {
+	return error instanceof AggregatedError;
+};
 
 //#endregion
-let __logtape_logtape = require("@logtape/logtape");
-__logtape_logtape = __toESM(__logtape_logtape);
-let picocolors = require("picocolors");
-picocolors = __toESM(picocolors);
+//#region src/stream/pipe.ts
+/**
+* @param source - The source stream.
+* @param operators - The operators to apply.
+* @returns The result of the last operator.
+*/
+function pipe(source, ...operators) {
+	return operators.reduce((src, operator) => operator(src), source);
+}
 
-//#region src/errors.ts
+//#endregion
+//#region src/stream/operators/share.ts
+/**
+* Shares a single source across multiple subscribers (multicast).
+* The source is only executed once, and all subscribers receive the same values.
+* This is essential for deduplication and caching scenarios.
+* @returns An operator that shares the source.
+*/
+const share = () => {
+	return (source) => {
+		const sinks = [];
+		let subscription = null;
+		let started = false;
+		let completed = false;
+		return (sink) => {
+			if (completed) {
+				sink.complete();
+				return { unsubscribe() {} };
+			}
+			sinks.push(sink);
+			if (!started) {
+				started = true;
+				subscription = source({
+					next(value) {
+						for (const s of [...sinks]) {
+							if (completed) break;
+							s.next(value);
+						}
+					},
+					complete() {
+						if (!completed) {
+							completed = true;
+							for (const s of [...sinks]) s.complete();
+							sinks.length = 0;
+						}
+					}
+				});
+			}
+			return { unsubscribe() {
+				const idx = sinks.indexOf(sink);
+				if (idx !== -1) sinks.splice(idx, 1);
+				if (sinks.length === 0 && subscription) {
+					subscription.unsubscribe();
+					subscription = null;
+					started = false;
+				}
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/exchanges/compose.ts
+const composeExchange = (options) => {
+	const { exchanges } = options;
+	return ({ forward, client }) => {
+		return exchanges.reduceRight((forward$1, exchange) => {
+			return (ops$) => {
+				return pipe(ops$, share(), exchange({
+					forward: forward$1,
+					client
+				}), share());
+			};
+		}, forward);
+	};
+};
+
+//#endregion
+//#region src/stream/operators/merge-map.ts
 /**
-* Custom error class for Mearie-specific errors.
-*/
-var MearieError = class MearieError extends Error {
-	filePath;
-	line;
-	column;
-	constructor(message, filePath, line, column) {
-		super(message);
-		this.name = "MearieError";
-		this.filePath = filePath;
-		this.line = line;
-		this.column = column;
+* Maps each value to a source and flattens all sources into a single output source.
+* Similar to flatMap. Values from all inner sources are merged concurrently.
+* @param fn - Function that returns a source for each value.
+* @returns An operator that flattens mapped sources.
+*/
+const mergeMap = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let outerCompleted = false;
+			let activeInner = 0;
+			let ended = false;
+			const innerSubscriptions = [];
+			const checkComplete = () => {
+				if (outerCompleted && activeInner === 0 && !ended) {
+					ended = true;
+					sink.complete();
+				}
+			};
+			const outerSubscription = source({
+				next(value) {
+					if (ended) return;
+					activeInner++;
+					const innerSubscription = fn(value)({
+						next(innerValue) {
+							if (!ended) sink.next(innerValue);
+						},
+						complete() {
+							activeInner--;
+							checkComplete();
+						}
+					});
+					innerSubscriptions.push(innerSubscription);
+				},
+				complete() {
+					outerCompleted = true;
+					checkComplete();
+				}
+			});
+			return { unsubscribe() {
+				ended = true;
+				outerSubscription.unsubscribe();
+				for (const sub of innerSubscriptions) sub.unsubscribe();
+				innerSubscriptions.length = 0;
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/filter.ts
+function filter(predicate) {
+	return (source) => {
+		return (sink) => {
+			return source({
+				next(value) {
+					if (predicate(value)) sink.next(value);
+				},
+				complete() {
+					sink.complete();
+				}
+			});
+		};
+	};
+}
+
+//#endregion
+//#region src/stream/sources/from-promise.ts
+const fromPromise = (promise) => {
+	return (sink) => {
+		let cancelled = false;
+		promise.then((value) => {
+			if (!cancelled) {
+				sink.next(value);
+				sink.complete();
+			}
+		}, () => {
+			if (!cancelled) sink.complete();
+		});
+		return { unsubscribe() {
+			cancelled = true;
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/operators/merge.ts
+/**
+* Merges multiple sources into a single source.
+* Values are emitted as soon as they arrive from any source.
+* Completes when all sources complete.
+* @param sources - The sources to merge.
+* @returns A merged source.
+*/
+const merge = (...sources) => {
+	return (sink) => {
+		if (sources.length === 0) {
+			sink.complete();
+			return { unsubscribe() {} };
+		}
+		let activeCount = sources.length;
+		const subscriptions = [];
+		let ended = false;
+		let ready = false;
+		const buffer = [];
+		const checkComplete = () => {
+			if (activeCount === 0 && !ended) {
+				ended = true;
+				sink.complete();
+			}
+		};
+		for (const source of sources) {
+			const subscription = source({
+				next(value) {
+					if (!ended) if (ready) sink.next(value);
+					else buffer.push(value);
+				},
+				complete() {
+					activeCount--;
+					if (ready) checkComplete();
+				}
+			});
+			subscriptions.push(subscription);
+		}
+		ready = true;
+		for (const value of buffer) if (!ended) sink.next(value);
+		buffer.length = 0;
+		checkComplete();
+		return { unsubscribe() {
+			ended = true;
+			for (const sub of subscriptions) sub.unsubscribe();
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/operators/tap.ts
+/**
+* Executes a side effect for each value without modifying the stream.
+* Useful for debugging, logging, or triggering side effects.
+* @param fn - The side effect function.
+* @returns An operator that taps into the stream.
+*/
+const tap = (fn) => {
+	return (source) => {
+		return (sink) => {
+			return source({
+				next(value) {
+					fn(value);
+					sink.next(value);
+				},
+				complete() {
+					sink.complete();
+				}
+			});
+		};
+	};
+};
+
+//#endregion
+//#region src/exchanges/http.ts
+const executeFetch = async ({ url, fetchOptions, operation, signal }) => {
+	const { artifact, variables } = operation;
+	let response;
+	try {
+		await Promise.resolve();
+		response = await fetch(url, {
+			method: "POST",
+			mode: fetchOptions.mode,
+			credentials: fetchOptions.credentials,
+			headers: {
+				"Content-Type": "application/json",
+				...fetchOptions.headers
+			},
+			body: JSON.stringify({
+				query: artifact.body,
+				variables
+			}),
+			signal
+		});
+	} catch (error) {
+		if (error instanceof Error && error.name === "AbortError") return null;
+		return {
+			operation,
+			errors: [new ExchangeError(error instanceof Error ? error.message : "Network error", {
+				exchangeName: "http",
+				cause: error
+			})]
+		};
 	}
-	static fromNative(data) {
-		if (!data || typeof data !== "object") throw new TypeError("Invalid native error data");
-		const error = data;
-		const filePath = error.location?.file_path;
-		const line = error.location?.line;
-		const column = error.location?.column;
-		return new MearieError(error.message, filePath, line, column);
+	if (!response.ok) return {
+		operation,
+		errors: [new ExchangeError(`HTTP ${response.status}: ${response.statusText}`, {
+			exchangeName: "http",
+			extensions: { statusCode: response.status }
+		})]
+	};
+	let json;
+	try {
+		json = await response.json();
+	} catch (error) {
+		return {
+			operation,
+			errors: [new ExchangeError(error instanceof Error ? error.message : "JSON parse error", {
+				exchangeName: "http",
+				cause: error
+			})]
+		};
 	}
+	return {
+		operation,
+		data: json.data,
+		errors: json.errors?.map((err) => new GraphQLError(err.message, {
+			path: err.path,
+			locations: err.locations,
+			extensions: err.extensions
+		})),
+		extensions: json.extensions
+	};
 };
+const httpExchange = (options) => {
+	const { url, headers, mode, credentials } = options;
+	return ({ forward }) => {
+		return (ops$) => {
+			const inflight = /* @__PURE__ */ new Map();
+			return merge(pipe(ops$, filter((op) => op.variant === "request" && (op.artifact.kind === "query" || op.artifact.kind === "mutation")), mergeMap((op) => {
+				inflight.get(op.key)?.abort();
+				const controller = new AbortController();
+				inflight.set(op.key, controller);
+				return fromPromise(executeFetch({
+					url,
+					fetchOptions: {
+						mode,
+						credentials,
+						headers
+					},
+					operation: op,
+					signal: controller.signal
+				}).then((result) => {
+					inflight.delete(op.key);
+					return result;
+				}));
+			}), filter((result) => result !== null)), pipe(ops$, filter((op) => op.variant === "teardown" || op.variant === "request" && (op.artifact.kind === "subscription" || op.artifact.kind === "fragment")), tap((op) => {
+				if (op.variant === "teardown") {
+					inflight.get(op.key)?.abort();
+					inflight.delete(op.key);
+				}
+			}), forward));
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/delay.ts
 /**
-* Aggregate error for multiple Mearie errors.
+* Delays each value emitted by a source by the specified time.
+* @param ms - The time (in milliseconds) to delay each value.
+* @returns An operator that delays values.
 */
-var MearieAggregateError = class extends Error {
-	errors;
-	constructor(errors, message) {
-		super(message ?? `${errors.length} error${errors.length > 1 ? "s" : ""} occurred`);
-		this.name = "MearieAggregateError";
-		this.errors = errors;
-	}
+const delay = (ms) => {
+	return (source) => {
+		return (sink) => {
+			let cancelled = false;
+			const timeouts = [];
+			const upstreamSubscription = source({
+				next(value) {
+					const timeout = setTimeout(() => {
+						if (!cancelled) sink.next(value);
+					}, ms);
+					timeouts.push(timeout);
+				},
+				complete() {
+					const timeout = setTimeout(() => {
+						if (!cancelled) sink.complete();
+					}, ms);
+					timeouts.push(timeout);
+				}
+			});
+			return { unsubscribe() {
+				cancelled = true;
+				for (const timeout of timeouts) clearTimeout(timeout);
+				timeouts.length = 0;
+				upstreamSubscription.unsubscribe();
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/sources/from-array.ts
+/**
+* Creates a source that emits values from an array and completes.
+* @param values - The array of values to emit.
+* @returns A source containing the array values.
+*/
+const fromArray = (values) => {
+	return (sink) => {
+		let cancelled = false;
+		for (const value of values) {
+			if (cancelled) break;
+			sink.next(value);
+		}
+		if (!cancelled) sink.complete();
+		return { unsubscribe() {
+			cancelled = true;
+		} };
+	};
 };
 
 //#endregion
@@ -71,264 +471,378 @@ var MearieAggregateError = class extends Error {
 * @param value - The value to stringify.
 * @returns The stable JSON string.
 */
-const stableStringify = (value) => {
+const stringify = (value) => {
 	if (value === null) return "null";
 	if (value === void 0) return "undefined";
 	const type = typeof value;
 	if (type === "string") return JSON.stringify(value);
 	if (type === "number" || type === "boolean") return String(value);
-	if (Array.isArray(value)) return "[" + value.map((v) => stableStringify(v)).join(",") + "]";
+	if (Array.isArray(value)) return "[" + value.map((v) => stringify(v)).join(",") + "]";
 	if (type === "object") {
 		const obj = value;
-		return "{" + Object.keys(obj).toSorted().map((k) => `"${k}":${stableStringify(obj[k])}`).join(",") + "}";
+		return "{" + Object.keys(obj).toSorted().filter((k) => obj[k] !== void 0).map((k) => `"${k}":${stringify(obj[k])}`).join(",") + "}";
 	}
 	return JSON.stringify(value) ?? "";
 };
 /**
-* Hash a string using FNV-1a algorithm.
+* Type guard to check if a value is nullish.
 * @internal
-* @param str - The string to hash.
-* @returns The hash value.
-*/
-const hashString = (str) => {
-	const FNV_OFFSET = 2166136261;
-	const FNV_PRIME = 16777619;
-	let hash = FNV_OFFSET;
-	for (let i = 0; i < str.length; i++) {
-		hash ^= str.codePointAt(i) ?? 0;
-		hash = Math.imul(hash, FNV_PRIME);
-	}
-	return hash >>> 0;
+* @param value - Value to check.
+* @returns True if the value is nullish.
+*/
+const isNullish = (value) => {
+	return value === void 0 || value === null;
 };
+
+//#endregion
+//#region src/stream/operators/map.ts
 /**
-* Combine two hashes using FNV-1a algorithm.
-* Used for query key generation.
-* @internal
-* @param hash1 - The first hash.
-* @param hash2 - The second hash.
-* @returns The combined hash.
-*/
-const combineHashes = (hash1, hash2) => {
-	const FNV_PRIME = 16777619;
-	let hash = hash1;
-	for (let i = 0; i < 4; i++) {
-		hash ^= hash2 >> i * 8 & 255;
-		hash = Math.imul(hash, FNV_PRIME);
-	}
-	return hash >>> 0;
+* Maps each value from the source through a transformation function.
+* @param fn - The transformation function.
+* @returns An operator that maps values.
+*/
+const map = (fn) => {
+	return (source) => {
+		return (sink) => {
+			return source({
+				next(value) {
+					sink.next(fn(value));
+				},
+				complete() {
+					sink.complete();
+				}
+			});
+		};
+	};
 };
 
 //#endregion
-//#region src/logger.ts
-(0, __logtape_logtape.configureSync)({
-	sinks: { console: (0, __logtape_logtape.getConsoleSink)({ formatter: (0, __logtape_logtape.getAnsiColorFormatter)({
-		level: "FULL",
-		timestamp: "time",
-		category: (category) => `💬 ${category.join("·")}`
-	}) }) },
-	loggers: [{
-		category: "mearie",
-		lowestLevel: "info",
-		sinks: ["console"]
-	}, {
-		category: ["logtape", "meta"],
-		lowestLevel: "warning",
-		sinks: ["console"]
-	}]
-});
-const logger = (0, __logtape_logtape.getLogger)(["mearie"]);
-const formatMearieError = (error) => {
-	const parts = [
-		error.filePath,
-		error.line,
-		error.column
-	].filter((part) => part !== void 0 && part !== null).map(String);
-	const location = parts.length > 0 ? parts.join(":") : "";
-	if (location) return `${picocolors.default.bold(error.message)} ${picocolors.default.cyan(picocolors.default.underline(location))}`;
-	return picocolors.default.bold(error.message);
-};
+//#region src/stream/operators/take-until.ts
 /**
-* Reports an error using the provided logger.
-* @param logger - The logger to use.
-* @param error - The error to report.
+* Emits values from the source until the notifier source emits a value.
+* When the notifier emits, the source is cancelled and completes immediately.
+* @param notifier - Source that signals when to complete.
+* @returns Operator that completes when notifier emits.
 */
-const report = (logger$1, error) => {
-	if (error instanceof MearieAggregateError) for (const err of error.errors) logger$1.error(formatMearieError(err));
-	else if (error instanceof MearieError) logger$1.error(formatMearieError(error));
-	else logger$1.error("{error}", { error });
+const takeUntil = (notifier) => {
+	return (source) => {
+		return (sink) => {
+			let sourceSubscription = null;
+			let notifierSubscription = null;
+			let completed = false;
+			const complete = () => {
+				if (completed) return;
+				completed = true;
+				if (sourceSubscription) sourceSubscription.unsubscribe();
+				if (notifierSubscription) notifierSubscription.unsubscribe();
+				sink.complete();
+			};
+			notifierSubscription = notifier({
+				next() {
+					complete();
+				},
+				complete() {}
+			});
+			sourceSubscription = source({
+				next(value) {
+					if (!completed) sink.next(value);
+				},
+				complete() {
+					complete();
+				}
+			});
+			return { unsubscribe() {
+				complete();
+			} };
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/operators/switch-map.ts
+const switchMap = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let outerCompleted = false;
+			let ended = false;
+			let innerSubscription = null;
+			let hasInner = false;
+			const checkComplete = () => {
+				if (outerCompleted && !hasInner && !ended) {
+					ended = true;
+					sink.complete();
+				}
+			};
+			const outerSubscription = source({
+				next(value) {
+					if (ended) return;
+					if (innerSubscription) {
+						innerSubscription.unsubscribe();
+						innerSubscription = null;
+					}
+					hasInner = true;
+					innerSubscription = fn(value)({
+						next(innerValue) {
+							if (!ended) sink.next(innerValue);
+						},
+						complete() {
+							hasInner = false;
+							innerSubscription = null;
+							checkComplete();
+						}
+					});
+				},
+				complete() {
+					outerCompleted = true;
+					checkComplete();
+				}
+			});
+			return { unsubscribe() {
+				ended = true;
+				outerSubscription.unsubscribe();
+				if (innerSubscription) {
+					innerSubscription.unsubscribe();
+					innerSubscription = null;
+				}
+			} };
+		};
+	};
 };
 
 //#endregion
-//#region src/link.ts
+//#region src/stream/operators/initialize.ts
 /**
-* @param links - The chain of links to execute.
-* @param ctx - The link context.
-* @param finalHandler - The final handler function.
-* @returns The link result.
+* Executes a side effect when the source is initialized (being subscribed to).
+* @param fn - The side effect function.
+* @returns An operator that executes the side effect when the source is initialized.
 */
-const executeLinks = (links, ctx, finalHandler) => {
-	let index = 0;
-	const dispatch = async () => {
-		if (index >= links.length) return await finalHandler(ctx);
-		const link = links[index++];
-		if (!link) throw new Error("Link is undefined");
-		return link.execute(ctx, dispatch);
+const initialize = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let completed = false;
+			const subscription = source({
+				next(value) {
+					if (!completed) sink.next(value);
+				},
+				complete() {
+					if (!completed) {
+						completed = true;
+						sink.complete();
+					}
+				}
+			});
+			fn();
+			return { unsubscribe() {
+				completed = true;
+				subscription.unsubscribe();
+			} };
+		};
 	};
-	return dispatch();
 };
 
 //#endregion
-//#region src/links/dedup.ts
+//#region src/stream/operators/finalize.ts
 /**
-* @returns The deduplication link.
+* Executes a side effect when the source terminates (completes or unsubscribes).
+* @param fn - The side effect function.
+* @returns An operator that executes the side effect when the source terminates.
 */
-const createDedupLink = () => {
-	const pending = /* @__PURE__ */ new Map();
-	return {
-		name: "dedup",
-		async execute(ctx, next) {
-			const { document, variables } = ctx.operation;
-			const queryHash = document.hash;
-			const key = combineHashes(queryHash, variables ? hashString(stableStringify(variables)) : 0);
-			const existing = pending.get(key);
-			if (existing) return existing;
-			const promise = next();
-			pending.set(key, promise);
-			try {
-				return await promise;
-			} finally {
-				pending.delete(key);
-			}
-		}
+const finalize = (fn) => {
+	return (source) => {
+		return (sink) => {
+			let completed = false;
+			const subscription = source({
+				next(value) {
+					if (!completed) sink.next(value);
+				},
+				complete() {
+					if (!completed) {
+						completed = true;
+						fn();
+						sink.complete();
+					}
+				}
+			});
+			return { unsubscribe() {
+				if (!completed) {
+					completed = true;
+					fn();
+				}
+				subscription.unsubscribe();
+			} };
+		};
 	};
 };
-const dedupLink = createDedupLink;
 
 //#endregion
-//#region src/links/retry.ts
+//#region src/stream/sources/from-value.ts
 /**
-* @param options - The retry options.
-* @returns The retry link.
+* Creates a source that emits a single value and completes.
+* @param value - The value to emit.
+* @returns A source containing the single value.
 */
-const createRetryLink = (options = {}) => {
-	const { maxAttempts = 3, backoff = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4), shouldRetry = () => true } = options;
-	return {
-		name: "retry",
-		async execute(ctx, next) {
-			let lastError;
-			for (let attempt = 0; attempt < maxAttempts; attempt++) try {
-				return await next();
-			} catch (error) {
-				lastError = error;
-				if (attempt === maxAttempts - 1 || !shouldRetry(error)) throw error;
-				const delay = backoff(attempt);
-				await new Promise((resolve) => setTimeout(resolve, delay));
-			}
-			throw lastError;
+const fromValue = (value) => {
+	return (sink) => {
+		let cancelled = false;
+		if (!cancelled) {
+			sink.next(value);
+			sink.complete();
 		}
+		return { unsubscribe() {
+			cancelled = true;
+		} };
 	};
 };
-const retryLink = createRetryLink;
 
 //#endregion
-//#region src/links/fetch.ts
+//#region src/stream/sources/make-subject.ts
 /**
-* @param options - The HTTP options.
-* @returns The HTTP link.
+* Creates a new Subject which can be used as an IO event hub.
+* @returns A new Subject.
 */
-const createHttpLink = (options) => {
-	const { url, credentials = "same-origin", headers = {} } = options;
+const makeSubject = () => {
+	const sinks = [];
+	const source = (sink) => {
+		sinks.push(sink);
+		return { unsubscribe() {
+			const idx = sinks.indexOf(sink);
+			if (idx !== -1) sinks.splice(idx, 1);
+		} };
+	};
+	const next = (value) => {
+		for (const sink of [...sinks]) sink.next(value);
+	};
+	const complete = () => {
+		for (const sink of [...sinks]) sink.complete();
+		sinks.length = 0;
+	};
 	return {
-		name: "http",
-		async execute(ctx) {
-			const { document, variables, headers: operationHeaders } = ctx.operation;
-			const response = await fetch(url, {
-				method: "POST",
-				credentials,
-				headers: {
-					"Content-Type": "application/json",
-					...headers,
-					...operationHeaders
-				},
-				body: JSON.stringify({
-					query: document.body,
-					variables
-				}),
-				signal: ctx.signal
-			});
-			if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-			return response.json();
-		}
+		source,
+		next,
+		complete
 	};
 };
-const httpLink = createHttpLink;
 
 //#endregion
-//#region src/links/auth.ts
+//#region src/stream/sources/from-subscription.ts
+const fromSubscription = (pull, poke) => {
+	return (sink) => {
+		let teardown = null;
+		let cancelled = false;
+		const initialValue = pull();
+		sink.next(initialValue);
+		if (cancelled) return { unsubscribe() {
+			cancelled = true;
+		} };
+		teardown = poke(() => {
+			if (!cancelled) {
+				const value = pull();
+				sink.next(value);
+			}
+		});
+		return { unsubscribe() {
+			cancelled = true;
+			if (teardown) {
+				teardown();
+				teardown = null;
+			}
+		} };
+	};
+};
+
+//#endregion
+//#region src/stream/sources/make.ts
 /**
-* @param options - The authentication options.
-* @returns The authentication link.
+* Creates a new Source from scratch from a passed subscriber function.
+*
+* The subscriber function receives an observer with next and complete callbacks.
+* It must return a teardown function which is called when the source is cancelled.
+* @internal
+* @param subscriber - A callback that is called when the Source is subscribed to.
+* @returns A Source created from the subscriber parameter.
 */
-const createAuthLink = (options) => {
-	const { getToken, refreshToken, header = "Authorization" } = options;
-	return {
-		name: "auth",
-		async execute(ctx, next) {
-			const token = await getToken();
-			if (token) ctx.operation.headers = {
-				...ctx.operation.headers,
-				[header]: `Bearer ${token}`
-			};
-			try {
-				return await next();
-			} catch (error) {
-				if (refreshToken && typeof error === "object" && error !== null && "response" in error && typeof error.response === "object" && error.response !== null && "status" in error.response && error.response.status === 401) {
-					const newToken = await refreshToken();
-					ctx.operation.headers = {
-						...ctx.operation.headers,
-						[header]: `Bearer ${newToken}`
-					};
-					return next();
+const make = (subscriber) => {
+	return (sink) => {
+		let cancelled = false;
+		let teardown = null;
+		teardown = subscriber({
+			next: (value) => {
+				if (!cancelled) sink.next(value);
+			},
+			complete: () => {
+				if (!cancelled) {
+					cancelled = true;
+					if (teardown) {
+						teardown();
+						teardown = null;
+					}
+					sink.complete();
 				}
-				throw error;
 			}
-		}
+		});
+		return { unsubscribe() {
+			cancelled = true;
+			if (teardown) {
+				teardown();
+				teardown = null;
+			}
+		} };
 	};
 };
-const authLink = createAuthLink;
 
 //#endregion
-//#region src/links/cache.ts
+//#region src/exchanges/dedup.ts
+const makeDedupKey = (op) => {
+	return `${op.artifact.name}:${stringify(op.variables)}`;
+};
 /**
-* @param options - The cache options.
-* @returns The cache link.
+* Prevents duplicate in-flight operations by deduplicating requests with identical artifact names and variables.
+*
+* Operations are considered identical if they have the same artifact name and serialized variables.
+* Mutations are never deduplicated. An operation is "in-flight" from when it's first seen until all subscribers tear down.
+*
+* Caveats:
+*
+* 1. Upstream metadata is lost when operations are deduplicated. The result will contain the metadata
+* from the operation that actually went through the pipeline, not from deduplicated operations.
+* This preserves downstream metadata (retry attempts, cache status) but means custom upstream metadata
+* from deduplicated operations will not appear in results.
+* @internal
+* @returns An exchange that deduplicates in-flight operations.
 */
-const createCacheLink = (options) => {
-	const { cache, fetchPolicy = "cache-first" } = options;
-	return {
-		name: "cache",
-		async execute(ctx, next) {
-			const { document, variables, kind } = ctx.operation;
-			if (kind === "mutation" || kind === "subscription") {
-				const result$1 = await next();
-				if (kind === "mutation" && result$1.data) cache.writeQuery(document, variables, result$1.data);
-				return result$1;
-			}
-			if (fetchPolicy === "network-only") {
-				const result$1 = await next();
-				if (result$1.data) cache.writeQuery(document, variables, result$1.data);
-				return result$1;
-			}
-			const cached = cache.readQuery(document, variables);
-			if (fetchPolicy === "cache-only") return { data: cached ?? void 0 };
-			if (fetchPolicy === "cache-first" && cached) return { data: cached };
-			const result = await next();
-			if (result.data) cache.writeQuery(document, variables, result.data);
-			return result;
-		}
+const dedupExchange = () => {
+	return ({ forward }) => {
+		return (ops$) => {
+			const operations = /* @__PURE__ */ new Map();
+			return pipe(merge(pipe(ops$, filter((op) => op.variant === "request" && (op.artifact.kind === "mutation" || op.artifact.kind === "fragment"))), pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind !== "mutation" && op.artifact.kind !== "fragment"), filter((op) => {
+				const dedupKey = makeDedupKey(op);
+				const isInflight = operations.has(dedupKey);
+				if (isInflight) operations.get(dedupKey).add(op.key);
+				else operations.set(dedupKey, new Set([op.key]));
+				return (op.metadata.dedup?.skip ?? false) || !isInflight;
+			}), delay(0)), pipe(ops$, filter((op) => op.variant === "teardown"), filter((teardown) => {
+				for (const [dedupKey, subs] of operations.entries()) if (subs.delete(teardown.key)) {
+					if (subs.size === 0) {
+						operations.delete(dedupKey);
+						return true;
+					}
+					return false;
+				}
+				return true;
+			}))), forward, mergeMap((result) => {
+				if (result.operation.variant !== "request" || result.operation.artifact.kind === "mutation" || result.operation.artifact.kind === "fragment") return fromValue(result);
+				const dedupKey = makeDedupKey(result.operation);
+				return fromArray([...operations.get(dedupKey) ?? /* @__PURE__ */ new Set()].map((key) => ({
+					...result,
+					operation: {
+						...result.operation,
+						key
+					}
+				})));
+			}));
+		};
 	};
 };
-const cacheLink = createCacheLink;
 
 //#endregion
 //#region src/cache/constants.ts
@@ -344,6 +858,12 @@ const EntityLinkKey = "__ref";
 * @internal
 */
 const RootFieldKey = "__root";
+/**
+* Special key used to mark fragment references in entities.
+* Used for cache-agnostic fragment system.
+* @internal
+*/
+const FragmentRefKey = "__fragmentRef";
 
 //#endregion
 //#region src/cache/utils.ts
@@ -365,42 +885,19 @@ const makeEntityKey = (typename, keyValues) => {
 * @returns Object with all arguments resolved to their actual values.
 */
 const resolveArguments = (args, variables) => {
-	const resolved = {};
-	for (const [key, value] of Object.entries(args)) resolved[key] = value.kind === "literal" ? value.value : variables[value.name];
-	return resolved;
+	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, value.kind === "literal" ? value.value : variables[value.name]]));
 };
 /**
 * Generates a cache key for a GraphQL field selection.
-* Always uses the actual field name (not alias) with a hash of the arguments.
+* Always uses the actual field name (not alias) with a stringified representation of the arguments.
 * @internal
-* @param selection - The selection node containing field information.
+* @param selection - The field selection node containing field information.
 * @param variables - Variable values for resolving argument references.
-* @returns Field cache key string in "fieldName@argsHash" format.
+* @returns Field cache key string in "fieldName@argsString" format.
 */
 const makeFieldKey = (selection, variables) => {
-	const argsHash = hashString(stableStringify(selection.args ? resolveArguments(selection.args, variables) : {}));
-	return `${selection.name}@${argsHash}`;
-};
-/**
-* Retrieves entity metadata from the schema for a given typename.
-* @internal
-* @param typename - The GraphQL typename to look up.
-* @param schemaMetadata - The schema metadata containing entity configurations.
-* @returns Entity metadata if found, undefined otherwise.
-*/
-const getEntityMetadata = (typename, schemaMetadata) => {
-	return typename ? schemaMetadata.entities[typename] : void 0;
-};
-/**
-* Creates a unique query key combining document hash and variables.
-* @internal
-* @param hash - Document hash.
-* @param variables - Query variables.
-* @returns Unique query key.
-*/
-const makeQueryKey = (hash, variables) => {
-	if (!variables || typeof variables === "object" && Object.keys(variables).length === 0) return hash;
-	return combineHashes(hash, hashString(stableStringify(variables)));
+	const args = selection.args && Object.keys(selection.args).length > 0 ? stringify(resolveArguments(selection.args, variables)) : "{}";
+	return `${selection.name}@${args}`;
 };
 /**
 * Gets a unique key for tracking a field dependency.
@@ -421,109 +918,105 @@ const makeDependencyKey = (storageKey, fieldKey) => {
 const isEntityLink = (value) => {
 	return typeof value === "object" && value !== null && EntityLinkKey in value;
 };
+/**
+* Type guard to check if a value is a fragment reference.
+* @internal
+* @param value - Value to check.
+* @returns True if the value is a FragmentRef.
+*/
+const isFragmentRef = (value) => {
+	return typeof value === "object" && value !== null && FragmentRefKey in value;
+};
+/**
+* Type guard to check if a value is nullish.
+* @internal
+* @param value - Value to check.
+* @returns True if the value is nullish.
+*/
+const isNullish$1 = (value) => {
+	return value === void 0 || value === null;
+};
 
 //#endregion
 //#region src/cache/normalize.ts
-/**
-* @param data - The data to normalize.
-* @param selections - The selection nodes.
-* @param schemaMetadata - The schema metadata.
-* @param storage - The normalized storage map.
-* @param variables - The variable values.
-* @param accessor - Callback invoked when a field dependency is encountered.
-*/
-const normalize = (data, selections, schemaMetadata, storage, variables, accessor) => {
-	const normalizeField = (parentKey, selections$1, value) => {
-		if (value === null || value === void 0) return value;
-		if (typeof value !== "object" || Array.isArray(value)) return value;
+const normalize = (schemaMeta, selections, storage, data, variables, accessor) => {
+	const normalizeField = (storageKey, selections$1, value) => {
+		if (isNullish$1(value)) return value;
+		if (Array.isArray(value)) return value.map((item) => normalizeField(storageKey, selections$1, item));
 		const data$1 = value;
-		const fields = {};
-		for (const selection of selections$1) {
+		const typename = data$1.__typename;
+		const entityMeta = schemaMeta.entities[typename];
+		if (entityMeta) storageKey = makeEntityKey(typename, entityMeta.keyFields.map((field) => data$1[field]));
+		const fields$1 = {};
+		for (const selection of selections$1) if (selection.kind === "Field") {
 			const fieldKey = makeFieldKey(selection, variables);
 			const fieldValue = data$1[selection.alias ?? selection.name];
-			accessor(parentKey, fieldKey);
-			if (fieldValue === void 0) continue;
-			if (Array.isArray(fieldValue)) fields[fieldKey] = fieldValue.map((item) => selection.selections ? normalizeField(parentKey, selection.selections, item) : item);
-			else if (selection.selections) fields[fieldKey] = normalizeField(parentKey, selection.selections, fieldValue);
-			else fields[fieldKey] = fieldValue;
-		}
-		const typename = data$1.__typename;
-		const entityMetadata = typename ? getEntityMetadata(typename, schemaMetadata) : void 0;
-		if (entityMetadata) {
-			const keyValues = [];
-			for (const field of entityMetadata.keyFields) {
-				const fieldValue = data$1[field];
-				if (fieldValue == null) return fields;
-				keyValues.push(fieldValue);
+			if (storageKey !== null) {
+				const oldValue = storage[storageKey]?.[fieldKey];
+				if (!selection.selections || isNullish$1(oldValue) || isNullish$1(fieldValue)) accessor?.(storageKey, fieldKey, oldValue, fieldValue);
 			}
-			const entityKey = makeEntityKey(typename, keyValues);
-			const normalized = {
-				...storage.get(entityKey) ?? {},
-				...fields
+			fields$1[fieldKey] = selection.selections ? normalizeField(null, selection.selections, fieldValue) : fieldValue;
+		} else if (selection.kind === "FragmentSpread" || selection.kind === "InlineFragment" && selection.on === typename) {
+			const inner = normalizeField(storageKey, selection.selections, value);
+			if (!isEntityLink(inner)) Object.assign(fields$1, inner);
+		}
+		if (entityMeta && storageKey !== null) {
+			storage[storageKey] = {
+				...storage[storageKey],
+				...fields$1
 			};
-			storage.set(entityKey, normalized);
-			return { [EntityLinkKey]: entityKey };
+			return { [EntityLinkKey]: storageKey };
 		}
-		return fields;
+		return fields$1;
+	};
+	const fields = normalizeField(RootFieldKey, selections, data);
+	storage[RootFieldKey] = {
+		...storage[RootFieldKey],
+		...fields
 	};
-	if (data === null || typeof data !== "object") return;
-	const existingRoot = storage.get(RootFieldKey) ?? {};
-	const result = normalizeField(RootFieldKey, selections, data);
-	storage.set(RootFieldKey, {
-		...existingRoot,
-		...result
-	});
 };
 
 //#endregion
 //#region src/cache/denormalize.ts
-/**
-* @param value - The value to denormalize.
-* @param selection - The selection node.
-* @param storage - The normalized storage map.
-* @param variables - The variable values.
-* @param sourceData - The source data object.
-* @returns The denormalized value.
-*/
-const denormalizeValue = (value, selection, storage, variables, sourceData) => {
-	if (value === null || value === void 0) return value;
-	if (selection.array && Array.isArray(value)) return value.map((item) => denormalizeValue(item, selection, storage, variables, sourceData));
-	if (typeof value !== "object" || Array.isArray(value)) return value;
-	const data = value;
-	let source = sourceData ?? data;
-	if (isEntityLink(data)) {
-		const entity = storage.get(data[EntityLinkKey]);
-		if (!entity || !selection.selections) return value;
-		source = entity;
-		sourceData = entity;
-	}
-	if (!selection.selections) return value;
-	const result = {};
-	for (const childSelection of selection.selections) {
-		const fieldKey = sourceData ? makeFieldKey(childSelection, variables) : childSelection.alias ?? childSelection.name;
-		const responseKey = childSelection.alias ?? childSelection.name;
-		const fieldValue = source[fieldKey];
-		if (fieldValue !== void 0) result[responseKey] = denormalizeValue(fieldValue, childSelection, storage, variables, sourceData);
-	}
-	return result;
-};
-/**
-* @param selections - The selection nodes.
-* @param storage - The normalized storage map.
-* @param variables - The variable values.
-* @returns The denormalized data.
-*/
-const denormalize = (selections, storage, variables) => {
-	const queryRoot = storage.get(RootFieldKey);
-	if (!queryRoot) return null;
-	const result = {};
-	for (const selection of selections) {
-		const fieldKey = makeFieldKey(selection, variables);
-		const responseKey = selection.alias ?? selection.name;
-		const fieldValue = queryRoot[fieldKey];
-		if (fieldValue !== void 0) result[responseKey] = denormalizeValue(fieldValue, selection, storage, variables, queryRoot);
-	}
-	return Object.keys(result).length === 0 ? null : result;
+const typenameFieldKey = makeFieldKey({
+	kind: "Field",
+	name: "__typename"
+}, {});
+const denormalize = (selections, storage, value, variables, accessor) => {
+	let partial = false;
+	const denormalizeField = (storageKey, selections$1, value$1) => {
+		if (isNullish$1(value$1)) return value$1;
+		if (Array.isArray(value$1)) return value$1.map((item) => denormalizeField(storageKey, selections$1, item));
+		const data = value$1;
+		if (isEntityLink(data)) {
+			const entityKey = data[EntityLinkKey];
+			const entity = storage[entityKey];
+			if (!entity) {
+				accessor?.(entityKey, typenameFieldKey);
+				partial = true;
+				return null;
+			}
+			return denormalizeField(entityKey, selections$1, entity);
+		}
+		const fields = {};
+		for (const selection of selections$1) if (selection.kind === "Field") {
+			const fieldKey = makeFieldKey(selection, variables);
+			const fieldValue = data[fieldKey];
+			if (storageKey !== null) accessor?.(storageKey, fieldKey);
+			if (fieldValue === void 0) {
+				partial = true;
+				continue;
+			}
+			fields[selection.alias ?? selection.name] = selection.selections ? denormalizeField(null, selection.selections, fieldValue) : fieldValue;
+		} else if (selection.kind === "FragmentSpread") if (storageKey !== null && storageKey !== RootFieldKey) fields[FragmentRefKey] = storageKey;
+		else Object.assign(fields, denormalizeField(storageKey, selection.selections, value$1));
+		else if (selection.kind === "InlineFragment" && selection.on === data[typenameFieldKey]) Object.assign(fields, denormalizeField(storageKey, selection.selections, value$1));
+		return fields;
+	};
+	return {
+		data: denormalizeField(RootFieldKey, selections, value),
+		partial
+	};
 };
 
 //#endregion
@@ -533,191 +1026,486 @@ const denormalize = (selections, storage, variables) => {
 * Supports entity normalization, cache invalidation, and reactive updates through subscriptions.
 */
 var Cache = class {
-	#storage = /* @__PURE__ */ new Map();
-	#dependencies = /* @__PURE__ */ new Map();
-	#listeners = /* @__PURE__ */ new Map();
-	#schemaMetadata;
+	#schemaMeta;
+	#storage = { [RootFieldKey]: {} };
+	#subscriptions = /* @__PURE__ */ new Map();
 	constructor(schemaMetadata) {
-		this.#schemaMetadata = schemaMetadata;
+		this.#schemaMeta = schemaMetadata;
 	}
 	/**
-	* Writes a query result to the cache, normalizing entities and tracking dependencies.
-	* @param document - GraphQL document node.
+	* Writes a query result to the cache, normalizing entities.
+	* @param artifact - GraphQL document artifact.
 	* @param variables - Query variables.
-	* @param result - Query result data.
+	* @param data - Query result data.
 	*/
-	writeQuery(document, variables, result) {
-		const queryKey = makeQueryKey(document.hash, variables);
-		normalize(result, document.selections, this.#schemaMetadata, this.#storage, variables, (storageKey, fieldKey) => {
-			this.#trackDependency(queryKey, storageKey, fieldKey);
+	writeQuery(artifact, variables, data) {
+		const dependencies = /* @__PURE__ */ new Set();
+		const subscriptions = /* @__PURE__ */ new Set();
+		normalize(this.#schemaMeta, artifact.selections, this.#storage, data, variables, (storageKey, fieldKey, oldValue, newValue) => {
+			if (oldValue !== newValue) {
+				const dependencyKey = makeDependencyKey(storageKey, fieldKey);
+				dependencies.add(dependencyKey);
+			}
 		});
-		this.#notifyListeners(queryKey);
+		for (const dependency of dependencies) {
+			const ss = this.#subscriptions.get(dependency);
+			if (ss) for (const s of ss) subscriptions.add(s);
+		}
+		for (const subscription of subscriptions) subscription.listener();
 	}
 	/**
 	* Reads a query result from the cache, denormalizing entities if available.
-	* @param document - GraphQL document node.
+	* @param artifact - GraphQL document artifact.
 	* @param variables - Query variables.
 	* @returns Denormalized query result or null if not found.
 	*/
-	readQuery(document, variables) {
-		return denormalize(document.selections, this.#storage, variables);
+	readQuery(artifact, variables) {
+		const { data, partial } = denormalize(artifact.selections, this.#storage, this.#storage[RootFieldKey], variables);
+		return partial ? null : data;
 	}
 	/**
 	* Subscribes to cache invalidations for a specific query.
-	* @param document - GraphQL document node.
+	* @param artifact - GraphQL document artifact.
 	* @param variables - Query variables.
-	* @param callback - Callback function to invoke on cache invalidation.
+	* @param listener - Callback function to invoke on cache invalidation.
 	* @returns Unsubscribe function.
 	*/
-	subscribe(document, variables, callback) {
-		const queryKey = makeQueryKey(document.hash, variables);
-		let listeners = this.#listeners.get(queryKey);
-		if (!listeners) {
-			listeners = /* @__PURE__ */ new Set();
-			this.#listeners.set(queryKey, listeners);
-		}
-		listeners.add(callback);
-		return () => {
-			listeners.delete(callback);
-			if (listeners.size === 0) this.#listeners.delete(queryKey);
-		};
+	subscribeQuery(artifact, variables, listener) {
+		const dependencies = /* @__PURE__ */ new Set();
+		denormalize(artifact.selections, this.#storage, this.#storage[RootFieldKey], variables, (storageKey, fieldKey) => {
+			const dependencyKey = makeDependencyKey(storageKey, fieldKey);
+			dependencies.add(dependencyKey);
+		});
+		return this.#subscribe(dependencies, listener);
 	}
 	/**
-	* Evicts a query from the cache and notifies listeners.
-	* @param document - GraphQL document node.
-	* @param variables - Query variables.
+	* Reads a fragment from the cache for a specific entity.
+	* Returns null for invalid or missing fragment references, making it safe for
+	* defensive reads. For subscriptions, use subscribeFragment which throws errors.
+	* @param artifact - GraphQL fragment artifact.
+	* @param fragmentRef - Fragment reference containing entity key.
+	* @returns Denormalized fragment data or null if not found or invalid.
 	*/
-	evictQuery(document, variables) {
-		const queryKey = makeQueryKey(document.hash, variables);
-		const queryRoot = this.#storage.get(RootFieldKey);
-		if (queryRoot) for (const selection of document.selections) {
-			const fieldKey = makeFieldKey(selection, variables);
-			delete queryRoot[fieldKey];
+	readFragment(artifact, fragmentRef) {
+		const entityKey = fragmentRef[FragmentRefKey];
+		if (!this.#storage[entityKey]) return null;
+		const { data, partial } = denormalize(artifact.selections, this.#storage, { [EntityLinkKey]: entityKey }, {});
+		return partial ? null : data;
+	}
+	subscribeFragment(artifact, fragmentRef, listener) {
+		const entityKey = fragmentRef[FragmentRefKey];
+		const dependencies = /* @__PURE__ */ new Set();
+		denormalize(artifact.selections, this.#storage, { [EntityLinkKey]: entityKey }, {}, (storageKey, fieldKey) => {
+			const dependencyKey = makeDependencyKey(storageKey, fieldKey);
+			dependencies.add(dependencyKey);
+		});
+		return this.#subscribe(dependencies, listener);
+	}
+	#subscribe(dependencies, listener) {
+		const subscription = { listener };
+		for (const dependency of dependencies) {
+			const subscriptions = this.#subscriptions.get(dependency) ?? /* @__PURE__ */ new Set();
+			subscriptions.add(subscription);
+			this.#subscriptions.set(dependency, subscriptions);
 		}
-		this.#notifyListeners(queryKey);
+		return () => {
+			for (const dependency of dependencies) {
+				const subscriptions = this.#subscriptions.get(dependency);
+				subscriptions?.delete(subscription);
+				if (subscriptions?.size === 0) this.#subscriptions.delete(dependency);
+			}
+		};
 	}
 	/**
 	* Clears all cache data.
 	*/
 	clear() {
-		this.#storage.clear();
-		this.#dependencies.clear();
-		this.#listeners.clear();
+		this.#storage = { [RootFieldKey]: {} };
+		this.#subscriptions.clear();
 	}
-	/**
-	* Tracks dependency between a query and a storage field.
-	* @param queryKey - Query key to track.
-	* @param storageKey - Storage key (entity or root).
-	* @param fieldKey - Field key.
-	*/
-	#trackDependency(queryKey, storageKey, fieldKey) {
-		const dependencyKey = makeDependencyKey(storageKey, fieldKey);
-		let queryKeys = this.#dependencies.get(dependencyKey);
-		if (!queryKeys) {
-			queryKeys = /* @__PURE__ */ new Set();
-			this.#dependencies.set(dependencyKey, queryKeys);
+};
+
+//#endregion
+//#region src/exchanges/cache.ts
+const cacheExchange = (options = {}) => {
+	const { fetchPolicy = "cache-first" } = options;
+	return ({ forward, client }) => {
+		const cache = new Cache(client.schema);
+		return (ops$) => {
+			const fragment$ = pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "fragment"), mergeMap((op) => {
+				const fragmentRef = op.metadata?.fragmentRef;
+				if (!fragmentRef) return fromValue({
+					operation: op,
+					errors: [new ExchangeError("Fragment operation missing fragmentRef in metadata. This usually happens when the wrong fragment reference was passed.", { exchangeName: "cache" })]
+				});
+				if (!isFragmentRef(fragmentRef)) return fromValue({
+					operation: op,
+					data: fragmentRef,
+					errors: []
+				});
+				const trigger = makeSubject();
+				const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => trigger.complete()));
+				return pipe(merge(fromValue(void 0), trigger.source), switchMap(() => fromSubscription(() => cache.readFragment(op.artifact, fragmentRef), () => cache.subscribeFragment(op.artifact, fragmentRef, async () => {
+					await Promise.resolve();
+					trigger.next();
+				}))), takeUntil(teardown$), map((data) => ({
+					operation: op,
+					data,
+					errors: []
+				})));
+			}));
+			const nonCache$ = pipe(ops$, filter((op) => op.variant === "request" && (op.artifact.kind === "mutation" || op.artifact.kind === "subscription" || op.artifact.kind === "query" && fetchPolicy === "network-only")));
+			const query$ = pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "query" && fetchPolicy !== "network-only"), share());
+			return merge(fragment$, pipe(query$, mergeMap((op) => {
+				const trigger = makeSubject();
+				const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key), tap(() => trigger.complete()));
+				return pipe(merge(fromValue(void 0), trigger.source), switchMap(() => fromSubscription(() => cache.readQuery(op.artifact, op.variables), () => cache.subscribeQuery(op.artifact, op.variables, async () => {
+					await Promise.resolve();
+					trigger.next();
+				}))), takeUntil(teardown$), map((data) => ({
+					operation: op,
+					data,
+					errors: []
+				})));
+			}), filter((result) => fetchPolicy === "cache-only" || fetchPolicy === "cache-and-network" && result.data !== null || fetchPolicy === "cache-first" && result.data !== null)), pipe(merge(nonCache$, pipe(query$, filter((op) => {
+				const cached = cache.readQuery(op.artifact, op.variables);
+				return fetchPolicy === "cache-and-network" || cached === null;
+			})), pipe(ops$, filter((op) => op.variant === "teardown"))), forward, tap((result) => {
+				if (result.operation.variant === "request" && result.data) cache.writeQuery(result.operation.artifact, result.operation.variables, result.data);
+			}), filter((result) => result.operation.variant !== "request" || result.operation.artifact.kind !== "query" || fetchPolicy === "network-only")));
+		};
+	};
+};
+
+//#endregion
+//#region src/exchanges/retry.ts
+const defaultShouldRetry = (error) => isExchangeError(error, "http") && error.extensions?.statusCode !== void 0 && error.extensions.statusCode >= 500;
+const retryExchange = (options = {}) => {
+	const { maxAttempts = 3, backoff = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4), shouldRetry = defaultShouldRetry } = options;
+	return ({ forward }) => {
+		return (ops$) => {
+			const { source: retries$, next } = makeSubject();
+			const tornDown = /* @__PURE__ */ new Set();
+			const teardown$ = pipe(ops$, filter((op) => op.variant === "teardown"), tap((op) => {
+				tornDown.add(op.key);
+			}));
+			return pipe(merge(pipe(ops$, filter((op) => op.variant === "request")), pipe(retries$, filter((op) => !tornDown.has(op.key)), mergeMap((op) => {
+				const teardown$$1 = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key));
+				return pipe(fromValue(op), delay(op.metadata.retry.delay), takeUntil(teardown$$1));
+			})), teardown$), forward, filter((result) => {
+				if (!result.errors || result.errors.length === 0) return true;
+				if (result.operation.variant === "request" && result.operation.artifact.kind === "mutation") return true;
+				const attempt = result.operation.metadata.retry?.attempt ?? 0;
+				if (attempt >= maxAttempts - 1) return true;
+				if (!result.errors.some((error) => shouldRetry(error))) return true;
+				next({
+					...result.operation,
+					metadata: {
+						...result.operation.metadata,
+						dedup: { skip: true },
+						retry: {
+							attempt: attempt + 1,
+							delay: backoff(attempt)
+						}
+					}
+				});
+				return false;
+			}));
+		};
+	};
+};
+
+//#endregion
+//#region src/exchanges/fragment.ts
+const fragmentExchange = () => {
+	return ({ forward }) => {
+		return (ops$) => {
+			return merge(pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "fragment"), map((op) => {
+				const fragmentRef = op.metadata.fragmentRef;
+				if (!fragmentRef) return {
+					operation: op,
+					errors: [new ExchangeError("Fragment operation missing fragmentRef in metadata. This usually happens when the wrong fragment reference was passed.", { exchangeName: "fragment" })]
+				};
+				return {
+					operation: op,
+					data: fragmentRef
+				};
+			})), pipe(ops$, filter((op) => op.variant === "teardown" || op.artifact.kind !== "fragment"), forward));
+		};
+	};
+};
+
+//#endregion
+//#region src/exchanges/subscription.ts
+/**
+* Creates an exchange for handling GraphQL subscriptions using a subscription client.
+*
+* This exchange accepts subscription clients from graphql-ws, graphql-sse, or any client
+* implementing the Observer pattern.
+* @internal
+* @param options - Configuration options for the subscription exchange.
+* @returns An exchange that handles subscription operations.
+* @example
+* // With graphql-ws
+* import { createClient } from 'graphql-ws';
+*
+* const wsClient = createClient({
+*   url: 'ws://localhost:4000/graphql',
+* });
+*
+* subscriptionExchange({ client: wsClient })
+* @example
+* // With graphql-sse
+* import { createClient } from 'graphql-sse';
+*
+* const sseClient = createClient({
+*   url: 'http://localhost:4000/graphql/stream',
+* });
+*
+* subscriptionExchange({ client: sseClient })
+*/
+const subscriptionExchange = (options) => {
+	const { client } = options;
+	return ({ forward }) => {
+		return (ops$) => {
+			return merge(pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "subscription"), mergeMap((op) => {
+				const teardown$ = pipe(ops$, filter((operation) => operation.variant === "teardown" && operation.key === op.key));
+				return pipe(make((observer) => {
+					let unsubscribe;
+					let completed = false;
+					Promise.resolve().then(() => {
+						if (completed) return;
+						unsubscribe = client.subscribe({
+							query: op.artifact.body,
+							variables: op.variables
+						}, {
+							next: (result) => {
+								const response = result;
+								observer.next({
+									operation: op,
+									data: response.data,
+									errors: response.errors?.map((err) => new GraphQLError(err.message, {
+										path: err.path,
+										locations: err.locations,
+										extensions: err.extensions
+									})),
+									extensions: response.extensions
+								});
+							},
+							error: (error) => {
+								observer.next({
+									operation: op,
+									errors: [new ExchangeError(error instanceof Error ? error.message : String(error), {
+										exchangeName: "subscription",
+										cause: error
+									})]
+								});
+								observer.complete();
+							},
+							complete: observer.complete
+						});
+					});
+					return () => {
+						completed = true;
+						unsubscribe?.();
+					};
+				}), takeUntil(teardown$));
+			})), pipe(ops$, filter((op) => op.variant === "teardown" || op.artifact.kind !== "subscription"), forward));
+		};
+	};
+};
+
+//#endregion
+//#region src/scalars.ts
+const parse = (selections, scalars, value) => {
+	const parseValue = (selection, value$1) => {
+		if (isNullish(value$1)) return value$1;
+		if (selection.array && Array.isArray(value$1)) return value$1.map((item) => parseValue({
+			...selection,
+			array: false
+		}, item));
+		if (selection.selections) return parseField(selection.selections, value$1);
+		const transformer = scalars[selection.type];
+		if (transformer) return transformer.parse(value$1);
+		return value$1;
+	};
+	const parseField = (selections$1, value$1) => {
+		if (isNullish(value$1)) return value$1;
+		const data = value$1;
+		const fields = {};
+		for (const selection of selections$1) if (selection.kind === "Field") {
+			const fieldName = selection.alias ?? selection.name;
+			const fieldValue = data[fieldName];
+			fields[fieldName] = parseValue(selection, fieldValue);
+		} else if (selection.kind === "FragmentSpread" || selection.kind === "InlineFragment" && selection.on === data.__typename) Object.assign(fields, parseField(selection.selections, value$1));
+		return fields;
+	};
+	return parseField(selections, value);
+};
+const serialize = (schemaMeta, variableDefs, scalars, variables) => {
+	const serializeValue = (variableDef, value) => {
+		if (isNullish(value)) return value;
+		if (variableDef.array && Array.isArray(value)) return value.map((item) => serializeValue({
+			...variableDef,
+			array: false
+		}, item));
+		const input = schemaMeta.inputs[variableDef.type];
+		if (input) return serializeField(input.fields, value);
+		const transformer = scalars[variableDef.type];
+		if (transformer) return transformer.serialize(value);
+		return value;
+	};
+	const serializeField = (variableDefs$1, value) => {
+		if (isNullish(value)) return value;
+		const data = value;
+		const fields = {};
+		for (const variableDef of variableDefs$1) {
+			const variableValue = data[variableDef.name];
+			fields[variableDef.name] = serializeValue(variableDef, variableValue);
 		}
-		queryKeys.add(queryKey);
-	}
-	/**
-	* Notifies all listeners subscribed to a query.
-	* @param queryKey - Query key to notify listeners for.
-	*/
-	#notifyListeners(queryKey) {
-		const listeners = this.#listeners.get(queryKey);
-		if (listeners) for (const listener of listeners) listener();
-	}
+		return fields;
+	};
+	return serializeField(variableDefs, variables);
 };
 
 //#endregion
-//#region src/client.ts
+//#region src/exchanges/scalar.ts
+const scalarExchange = () => {
+	return ({ forward, client }) => {
+		return (ops$) => {
+			return pipe(ops$, map((op) => {
+				if (op.variant !== "request" || !op.artifact.variableDefs || !client.scalars) return op;
+				return {
+					...op,
+					variables: serialize(client.schema, op.artifact.variableDefs, client.scalars, op.variables)
+				};
+			}), forward, map((result) => {
+				if (result.operation.variant !== "request" || !result.data || !client.scalars) return result;
+				return {
+					...result,
+					data: parse(result.operation.artifact.selections, client.scalars, result.data)
+				};
+			}));
+		};
+	};
+};
+
+//#endregion
+//#region src/exchanges/terminal.ts
+const terminalExchange = () => {
+	return () => {
+		return (ops$) => {
+			return pipe(ops$, filter((op) => op.variant !== "teardown"), mergeMap((op) => fromValue({
+				operation: op,
+				errors: [new ExchangeError("No terminal exchange found in exchange chain. Did you forget to add httpExchange to your exchanges array?", { exchangeName: "terminal" })]
+			})));
+		};
+	};
+};
+
+//#endregion
+//#region src/stream/sources/never.ts
 /**
-* GraphQL client for executing queries and mutations.
+* Creates a source that never emits any values.
+* @returns A never source.
 */
+const never = () => {
+	return () => {
+		return { unsubscribe() {} };
+	};
+};
+
+//#endregion
+//#region src/client.ts
 var Client = class {
-	links;
-	cache;
-	/**
-	* @param config - The client configuration.
-	*/
+	#schema;
+	#scalars;
+	operations$;
+	results$;
 	constructor(config) {
-		this.links = config.links.map((link) => typeof link === "function" ? link() : link);
-		this.cache = config.cache;
+		this.#schema = config.schema;
+		this.#scalars = config.scalars;
+		const exchange = composeExchange({ exchanges: [
+			scalarExchange(),
+			...config.exchanges,
+			fragmentExchange(),
+			terminalExchange()
+		] });
+		this.operations$ = makeSubject();
+		this.results$ = exchange({
+			forward: never,
+			client: this
+		})(this.operations$.source);
 	}
-	/**
-	* @param document - The query document.
-	* @param variables - The query variables.
-	* @returns The query result.
-	*/
-	async query(document, variables) {
-		return { data: {} };
+	get schema() {
+		return this.#schema;
 	}
-	/**
-	* @param document - The mutation document.
-	* @param variables - The mutation variables.
-	* @returns The mutation result.
-	*/
-	async mutate(document, variables) {
-		return { data: {} };
+	get scalars() {
+		return this.#scalars;
 	}
-	/**
-	* @param document - The mutation document.
-	* @param variables - The mutation variables.
-	* @returns The mutation result.
-	*/
-	async mutation(document, variables) {
-		return { data: {} };
+	createOperationKey() {
+		return Math.random().toString(36).slice(2) + Date.now().toString(36);
 	}
-	/**
-	* @param document - The subscription document.
-	* @param variables - The subscription variables.
-	* @returns An observable of subscription results.
-	*/
-	subscription(document, variables) {
-		return { subscribe: () => ({ unsubscribe: () => {} }) };
+	createOperation(artifact, variables) {
+		return {
+			variant: "request",
+			key: this.createOperationKey(),
+			metadata: {},
+			artifact,
+			variables: variables ?? {}
+		};
 	}
-	/**
-	* @param fragment - The fragment document.
-	* @param fragmentRef - The fragment reference data.
-	* @returns The fragment data.
-	*/
-	readFragment(fragment, fragmentRef) {
-		return {};
+	executeOperation(operation) {
+		return pipe(this.results$, initialize(() => this.operations$.next(operation)), filter((result) => result.operation.key === operation.key), finalize(() => this.operations$.next({
+			variant: "teardown",
+			key: operation.key,
+			metadata: {}
+		})), share());
 	}
-	/**
-	* @returns The normalized cache instance.
-	*/
-	getCache() {
-		return this.cache;
+	executeQuery(artifact, ...[variables, options]) {
+		const operation = this.createOperation(artifact, variables);
+		return this.executeOperation(operation);
+	}
+	executeMutation(artifact, ...[variables, options]) {
+		const operation = this.createOperation(artifact, variables);
+		return this.executeOperation(operation);
+	}
+	executeSubscription(artifact, ...[variables, options]) {
+		const operation = this.createOperation(artifact, variables);
+		return this.executeOperation(operation);
+	}
+	executeFragment(artifact, fragmentRef, options) {
+		const operation = {
+			variant: "request",
+			key: this.createOperationKey(),
+			metadata: { fragmentRef },
+			artifact,
+			variables: {}
+		};
+		return this.executeOperation(operation);
+	}
+	dispose() {
+		this.operations$.complete();
 	}
 };
-/**
-* @param config - The client configuration.
-* @returns A new client instance.
-*/
 const createClient = (config) => {
 	return new Client(config);
 };
 
 //#endregion
-//#region src/index.ts
-const graphql = () => {};
-
-//#endregion
+exports.AggregatedError = AggregatedError;
 exports.Client = Client;
-exports.MearieAggregateError = MearieAggregateError;
-exports.MearieError = MearieError;
-exports.NormalizedCache = Cache;
-exports.authLink = authLink;
-exports.cacheLink = cacheLink;
-exports.combineHashes = combineHashes;
+exports.ExchangeError = ExchangeError;
+exports.GraphQLError = GraphQLError;
+exports.cacheExchange = cacheExchange;
+exports.composeExchange = composeExchange;
 exports.createClient = createClient;
-exports.dedupLink = dedupLink;
-exports.executeLinks = executeLinks;
-exports.graphql = graphql;
-exports.hashString = hashString;
-exports.httpLink = httpLink;
-exports.logger = logger;
-exports.report = report;
-exports.retryLink = retryLink;
-exports.stableStringify = stableStringify;
+exports.dedupExchange = dedupExchange;
+exports.fragmentExchange = fragmentExchange;
+exports.httpExchange = httpExchange;
+exports.isAggregatedError = isAggregatedError;
+exports.isExchangeError = isExchangeError;
+exports.isGraphQLError = isGraphQLError;
+exports.retryExchange = retryExchange;
+exports.stringify = stringify;
+exports.subscriptionExchange = subscriptionExchange;