@mearie/core 0.1.0 → 0.1.2

package/dist/index.cjs

@@ -1,3 +1,4 @@
+const require_stream = require('./stream-DXHFB0xP.cjs');
 
 //#region src/errors.ts
 /**
@@ -73,68 +74,6 @@ const isAggregatedError = (error) => {
 	return error instanceof AggregatedError;
 };
 
-//#endregion
-//#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);
-}
-
-//#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) => {
@@ -142,176 +81,15 @@ const composeExchange = (options) => {
 	return ({ forward, client }) => {
 		return exchanges.reduceRight((forward$1, exchange) => {
 			return (ops$) => {
-				return pipe(ops$, share(), exchange({
+				return require_stream.pipe(ops$, require_stream.share(), exchange({
 					forward: forward$1,
 					client
-				}), share());
+				}), require_stream.share());
 			};
 		}, forward);
 	};
 };
 
-//#endregion
-//#region src/stream/operators/merge-map.ts
-/**
-* 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 }) => {
@@ -378,11 +156,11 @@ const httpExchange = (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) => {
+			return require_stream.merge(require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && (op.artifact.kind === "query" || op.artifact.kind === "mutation")), require_stream.mergeMap((op) => {
 				inflight.get(op.key)?.abort();
 				const controller = new AbortController();
 				inflight.set(op.key, controller);
-				return fromPromise(executeFetch({
+				return require_stream.fromPromise(executeFetch({
 					url,
 					fetchOptions: {
 						mode,
@@ -395,7 +173,7 @@ const httpExchange = (options) => {
 					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) => {
+			}), require_stream.filter((result) => result !== null)), require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "teardown" || op.variant === "request" && (op.artifact.kind === "subscription" || op.artifact.kind === "fragment")), require_stream.tap((op) => {
 				if (op.variant === "teardown") {
 					inflight.get(op.key)?.abort();
 					inflight.delete(op.key);
@@ -441,27 +219,6 @@ const delay = (ms) => {
 	};
 };
 
-//#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
 //#region src/utils.ts
 /**
@@ -494,302 +251,6 @@ const isNullish = (value) => {
 	return value === void 0 || value === null;
 };
 
-//#endregion
-//#region src/stream/operators/map.ts
-/**
-* 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/stream/operators/take-until.ts
-/**
-* 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 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/stream/operators/initialize.ts
-/**
-* 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 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();
-			} };
-		};
-	};
-};
-
-//#endregion
-//#region src/stream/operators/finalize.ts
-/**
-* 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 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();
-			} };
-		};
-	};
-};
-
-//#endregion
-//#region src/stream/sources/from-value.ts
-/**
-* Creates a source that emits a single value and completes.
-* @param value - The value to emit.
-* @returns A source containing the single value.
-*/
-const fromValue = (value) => {
-	return (sink) => {
-		let cancelled = false;
-		if (!cancelled) {
-			sink.next(value);
-			sink.complete();
-		}
-		return { unsubscribe() {
-			cancelled = true;
-		} };
-	};
-};
-
-//#endregion
-//#region src/stream/sources/make-subject.ts
-/**
-* Creates a new Subject which can be used as an IO event hub.
-* @returns A new Subject.
-*/
-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 {
-		source,
-		next,
-		complete
-	};
-};
-
-//#endregion
-//#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
-/**
-* 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 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();
-				}
-			}
-		});
-		return { unsubscribe() {
-			cancelled = true;
-			if (teardown) {
-				teardown();
-				teardown = null;
-			}
-		} };
-	};
-};
-
 //#endregion
 //#region src/exchanges/dedup.ts
 const makeDedupKey = (op) => {
@@ -814,13 +275,13 @@ 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) => {
+			return require_stream.pipe(require_stream.merge(require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && (op.artifact.kind === "mutation" || op.artifact.kind === "fragment"))), require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && op.artifact.kind !== "mutation" && op.artifact.kind !== "fragment"), require_stream.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) => {
+			}), delay(0)), require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "teardown"), require_stream.filter((teardown) => {
 				for (const [dedupKey, subs] of operations.entries()) if (subs.delete(teardown.key)) {
 					if (subs.size === 0) {
 						operations.delete(dedupKey);
@@ -829,10 +290,10 @@ const dedupExchange = () => {
 					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);
+			}))), forward, require_stream.mergeMap((result) => {
+				if (result.operation.variant !== "request" || result.operation.artifact.kind === "mutation" || result.operation.artifact.kind === "fragment") return require_stream.fromValue(result);
 				const dedupKey = makeDedupKey(result.operation);
-				return fromArray([...operations.get(dedupKey) ?? /* @__PURE__ */ new Set()].map((key) => ({
+				return require_stream.fromArray([...operations.get(dedupKey) ?? /* @__PURE__ */ new Set()].map((key) => ({
 					...result,
 					operation: {
 						...result.operation,
@@ -1133,47 +594,47 @@ const cacheExchange = (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 fragment$ = require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && op.artifact.kind === "fragment"), require_stream.mergeMap((op) => {
 				const fragmentRef = op.metadata?.fragmentRef;
-				if (!fragmentRef) return fromValue({
+				if (!fragmentRef) return require_stream.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({
+				if (!isFragmentRef(fragmentRef)) return require_stream.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 () => {
+				const trigger = require_stream.makeSubject();
+				const teardown$ = require_stream.pipe(ops$, require_stream.filter((operation) => operation.variant === "teardown" && operation.key === op.key), require_stream.tap(() => trigger.complete()));
+				return require_stream.pipe(require_stream.merge(require_stream.fromValue(void 0), trigger.source), require_stream.switchMap(() => require_stream.fromSubscription(() => cache.readFragment(op.artifact, fragmentRef), () => cache.subscribeFragment(op.artifact, fragmentRef, async () => {
 					await Promise.resolve();
 					trigger.next();
-				}))), takeUntil(teardown$), map((data) => ({
+				}))), require_stream.takeUntil(teardown$), require_stream.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 () => {
+			const nonCache$ = require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && (op.artifact.kind === "mutation" || op.artifact.kind === "subscription" || op.artifact.kind === "query" && fetchPolicy === "network-only")));
+			const query$ = require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && op.artifact.kind === "query" && fetchPolicy !== "network-only"), require_stream.share());
+			return require_stream.merge(fragment$, require_stream.pipe(query$, require_stream.mergeMap((op) => {
+				const trigger = require_stream.makeSubject();
+				const teardown$ = require_stream.pipe(ops$, require_stream.filter((operation) => operation.variant === "teardown" && operation.key === op.key), require_stream.tap(() => trigger.complete()));
+				return require_stream.pipe(require_stream.merge(require_stream.fromValue(void 0), trigger.source), require_stream.switchMap(() => require_stream.fromSubscription(() => cache.readQuery(op.artifact, op.variables), () => cache.subscribeQuery(op.artifact, op.variables, async () => {
 					await Promise.resolve();
 					trigger.next();
-				}))), takeUntil(teardown$), map((data) => ({
+				}))), require_stream.takeUntil(teardown$), require_stream.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) => {
+			}), require_stream.filter((result) => fetchPolicy === "cache-only" || fetchPolicy === "cache-and-network" && result.data !== null || fetchPolicy === "cache-first" && result.data !== null)), require_stream.pipe(require_stream.merge(nonCache$, require_stream.pipe(query$, require_stream.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) => {
+			})), require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "teardown"))), forward, require_stream.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")));
+			}), require_stream.filter((result) => result.operation.variant !== "request" || result.operation.artifact.kind !== "query" || fetchPolicy === "network-only")));
 		};
 	};
 };
@@ -1185,15 +646,15 @@ 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 { source: retries$, next } = require_stream.makeSubject();
 			const tornDown = /* @__PURE__ */ new Set();
-			const teardown$ = pipe(ops$, filter((op) => op.variant === "teardown"), tap((op) => {
+			const teardown$ = require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "teardown"), require_stream.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) => {
+			return require_stream.pipe(require_stream.merge(require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request")), require_stream.pipe(retries$, require_stream.filter((op) => !tornDown.has(op.key)), require_stream.mergeMap((op) => {
+				const teardown$$1 = require_stream.pipe(ops$, require_stream.filter((operation) => operation.variant === "teardown" && operation.key === op.key));
+				return require_stream.pipe(require_stream.fromValue(op), delay(op.metadata.retry.delay), require_stream.takeUntil(teardown$$1));
+			})), teardown$), forward, require_stream.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;
@@ -1221,7 +682,7 @@ const retryExchange = (options = {}) => {
 const fragmentExchange = () => {
 	return ({ forward }) => {
 		return (ops$) => {
-			return merge(pipe(ops$, filter((op) => op.variant === "request" && op.artifact.kind === "fragment"), map((op) => {
+			return require_stream.merge(require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && op.artifact.kind === "fragment"), require_stream.map((op) => {
 				const fragmentRef = op.metadata.fragmentRef;
 				if (!fragmentRef) return {
 					operation: op,
@@ -1231,7 +692,7 @@ const fragmentExchange = () => {
 					operation: op,
 					data: fragmentRef
 				};
-			})), pipe(ops$, filter((op) => op.variant === "teardown" || op.artifact.kind !== "fragment"), forward));
+			})), require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "teardown" || op.artifact.kind !== "fragment"), forward));
 		};
 	};
 };
@@ -1269,9 +730,9 @@ 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) => {
+			return require_stream.merge(require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "request" && op.artifact.kind === "subscription"), require_stream.mergeMap((op) => {
+				const teardown$ = require_stream.pipe(ops$, require_stream.filter((operation) => operation.variant === "teardown" && operation.key === op.key));
+				return require_stream.pipe(require_stream.make((observer) => {
 					let unsubscribe;
 					let completed = false;
 					Promise.resolve().then(() => {
@@ -1310,8 +771,8 @@ const subscriptionExchange = (options) => {
 						completed = true;
 						unsubscribe?.();
 					};
-				}), takeUntil(teardown$));
-			})), pipe(ops$, filter((op) => op.variant === "teardown" || op.artifact.kind !== "subscription"), forward));
+				}), require_stream.takeUntil(teardown$));
+			})), require_stream.pipe(ops$, require_stream.filter((op) => op.variant === "teardown" || op.artifact.kind !== "subscription"), forward));
 		};
 	};
 };
@@ -1374,13 +835,13 @@ const serialize = (schemaMeta, variableDefs, scalars, variables) => {
 const scalarExchange = () => {
 	return ({ forward, client }) => {
 		return (ops$) => {
-			return pipe(ops$, map((op) => {
+			return require_stream.pipe(ops$, require_stream.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) => {
+			}), forward, require_stream.map((result) => {
 				if (result.operation.variant !== "request" || !result.data || !client.scalars) return result;
 				return {
 					...result,
@@ -1396,7 +857,7 @@ const scalarExchange = () => {
 const terminalExchange = () => {
 	return () => {
 		return (ops$) => {
-			return pipe(ops$, filter((op) => op.variant !== "teardown"), mergeMap((op) => fromValue({
+			return require_stream.pipe(ops$, require_stream.filter((op) => op.variant !== "teardown"), require_stream.mergeMap((op) => require_stream.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" })]
 			})));
@@ -1432,7 +893,7 @@ var Client = class {
 			fragmentExchange(),
 			terminalExchange()
 		] });
-		this.operations$ = makeSubject();
+		this.operations$ = require_stream.makeSubject();
 		this.results$ = exchange({
 			forward: never,
 			client: this
@@ -1457,11 +918,11 @@ var Client = class {
 		};
 	}
 	executeOperation(operation) {
-		return pipe(this.results$, initialize(() => this.operations$.next(operation)), filter((result) => result.operation.key === operation.key), finalize(() => this.operations$.next({
+		return require_stream.pipe(this.results$, require_stream.initialize(() => this.operations$.next(operation)), require_stream.filter((result) => result.operation.key === operation.key), require_stream.finalize(() => this.operations$.next({
 			variant: "teardown",
 			key: operation.key,
 			metadata: {}
-		})), share());
+		})), require_stream.share());
 	}
 	executeQuery(artifact, ...[variables, options]) {
 		const operation = this.createOperation(artifact, variables);