@nlozgachev/pipelined 0.65.0 → 0.67.0

package/dist/{Core-BHN87zoB.mjs → Core-BCN6WRzp.mjs}

@@ -284,6 +284,189 @@ const Equality = {
 	}
 };
 //#endregion
+//#region src/Core/EventBus.ts
+const makeEventBus = (options) => ({
+	options,
+	_listeners: /* @__PURE__ */ new Set(),
+	_listenerArray: null,
+	_queue: [],
+	_isEmitting: false
+});
+const emitEventBus = (target, message) => {
+	const targets = Array.isArray(target) ? target : [target];
+	const msg = message;
+	for (const bus of targets) {
+		bus._queue.push(msg);
+		if (!bus._isEmitting) {
+			bus._isEmitting = true;
+			try {
+				while (bus._queue.length > 0) {
+					const nextMsg = bus._queue.shift();
+					if (bus._listenerArray === null) bus._listenerArray = Array.from(bus._listeners);
+					const listeners = bus._listenerArray;
+					for (const listener of listeners) try {
+						listener(nextMsg);
+					} catch (err) {
+						if (bus.options?.onError) bus.options.onError(err);
+						else throw err;
+					}
+				}
+			} finally {
+				bus._isEmitting = false;
+			}
+		}
+	}
+};
+const forwardEventBus = (options) => {
+	const targets = Array.isArray(options.to) ? options.to : [options.to];
+	const filterSet = options.only ? new Set(options.only) : null;
+	const handler = (msg) => {
+		if (filterSet !== null && !filterSet.has(msg.kind)) return;
+		for (const target of targets) emitEventBus(target, msg);
+	};
+	options.from._listeners.add(handler);
+	options.from._listenerArray = null;
+	return () => {
+		options.from._listeners.delete(handler);
+		options.from._listenerArray = null;
+	};
+};
+const listenEventBus = (bus, events, options) => {
+	const eventList = Array.isArray(events) ? events : [events];
+	const isOrdered = options?.ordered ?? false;
+	const isStrict = options?.strict ?? false;
+	const isOnce = options?.once ?? false;
+	const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+	const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
+	const createMatcher = (onMatch) => {
+		let sequenceIndex = 0;
+		return (msg) => {
+			if (resetKinds !== null && resetKinds.has(msg.kind)) {
+				sequenceIndex = 0;
+				return;
+			}
+			if (!isOrdered) {
+				if (eventList.includes(msg.kind)) onMatch(msg);
+				return;
+			}
+			let expectedKind = eventList[sequenceIndex];
+			if (expectedKind !== msg.kind && optionalKinds !== null) {
+				let lookaheadIndex = sequenceIndex;
+				while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) lookaheadIndex++;
+				if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
+					sequenceIndex = lookaheadIndex;
+					expectedKind = eventList[sequenceIndex];
+				}
+			}
+			if (msg.kind === expectedKind) {
+				sequenceIndex++;
+				if (sequenceIndex === eventList.length) {
+					sequenceIndex = 0;
+					onMatch(msg);
+				}
+			} else if (isStrict) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+			else if (eventList.includes(msg.kind)) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+		};
+	};
+	return {
+		reduce: (reducer, initialState) => {
+			let currentState = initialState;
+			const listenerFn = createMatcher((msg) => {
+				currentState = reducer(msg, currentState);
+				if (isOnce) {
+					bus._listeners.delete(listenerFn);
+					bus._listenerArray = null;
+				}
+			});
+			const unsubscribe = () => {
+				bus._listeners.delete(listenerFn);
+				bus._listenerArray = null;
+			};
+			bus._listeners.add(listenerFn);
+			bus._listenerArray = null;
+			return {
+				unsubscribe,
+				getState: () => currentState
+			};
+		},
+		tap: (effect) => {
+			const listenerFn = createMatcher((msg) => {
+				effect(msg);
+				if (isOnce) {
+					bus._listeners.delete(listenerFn);
+					bus._listenerArray = null;
+				}
+			});
+			const unsubscribe = () => {
+				bus._listeners.delete(listenerFn);
+				bus._listenerArray = null;
+			};
+			bus._listeners.add(listenerFn);
+			bus._listenerArray = null;
+			return unsubscribe;
+		}
+	};
+};
+const EventBus = {
+	/**
+	* Constructs a new `EventBus` instance.
+	*
+	* @example
+	* ```ts
+	* const bus = EventBus.make<AppMessages>({ name: "app" });
+	* ```
+	*/
+	make: makeEventBus,
+	/**
+	* Emits a message payload to one or more target event buses.
+	*
+	* Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
+	*
+	* @example
+	* ```ts
+	* EventBus.emit(busA, {
+	*   kind: "userLoggedIn",
+	*   value: { userId: "user-1" },
+	* });
+	*
+	* EventBus.emit([busA, busB], {
+	*   kind: "userLoggedIn",
+	*   value: { userId: "user-1" },
+	* });
+	* ```
+	*/
+	emit: emitEventBus,
+	/**
+	* Forwards messages from one event bus to another (or multiple).
+	*
+	* @example
+	* ```ts
+	* const stop = EventBus.forward({
+	*   from: authBus,
+	*   to: analyticsBus,
+	*   only: ["userLoggedIn"],
+	* });
+	* ```
+	*/
+	forward: forwardEventBus,
+	/**
+	* Initiates listener registration on an event bus for specific event kind(s) or sequence.
+	*
+	* @example
+	* ```ts
+	* const sub = EventBus.listen(
+	*   appBus,
+	*   ["userLoggedIn", "checkoutStarted"],
+	*   { ordered: true }
+	* ).reduce(
+	*   (msg, state) => ({ count: state.count + 1 }),
+	*   { count: 0 }
+	* );
+	* ```
+	*/
+	listen: listenEventBus
+};
+//#endregion
 //#region src/Core/Lazy.ts
 const fromFn = (f) => {
 	let done = false;
@@ -484,6 +667,19 @@ const chainLogged = (f) => (data) => {
 	};
 };
 const Logged = {
+	/**
+	* Creates a `Logged` with a value and an optional initial log array.
+	*
+	* @example
+	* ```ts
+	* Logged.make(42);                  // { value: 42, log: [] }
+	* Logged.make(42, ["initialized"]); // { value: 42, log: ["initialized"] }
+	* ```
+	*/
+	make: (value, log = []) => ({
+		value,
+		log: [...log]
+	}),
 	from: {
 		/**
 		* Wraps a pure value into a `Logged` with an empty log.
@@ -548,11 +744,11 @@ const Logged = {
 	* };
 	* const arg: Logged<string, number> = { value: 5, log: ["arg-loaded"] };
 	*
-	* const result = pipe(fn, Logged.ap(arg));
+	* const result = pipe(fn, Logged.apply(arg));
 	* Logged.run(result); // [10, ["fn-loaded", "arg-loaded"]]
 	* ```
 	*/
-	ap: (arg) => (data) => ({
+	apply: (arg) => (data) => ({
 		value: data.value(arg.value),
 		log: [...data.log, ...arg.log]
 	}),
@@ -662,6 +858,8 @@ const Maybe = {
 		/**
 		* Type guard that checks if a Maybe is Some.
 		*
+		* @see {@link Maybe.is.none}
+		*
 		* @example
 		* ```ts
 		* const value = Maybe.make.some(42);
@@ -674,6 +872,8 @@ const Maybe = {
 		/**
 		* Type guard that checks if a Maybe is None.
 		*
+		* @see {@link Maybe.is.some}
+		*
 		* @example
 		* ```ts
 		* const value = Maybe.make.none();
@@ -722,7 +922,18 @@ const Maybe = {
 		* ); // Err("Value was missing")
 		* ```
 		*/
-		Result: (onNone) => (data) => isSome(data) ? Result.make.ok(data.value) : Result.make.err(onNone())
+		Result: (onNone) => (data) => isSome(data) ? Result.make.ok(data.value) : Result.make.err(onNone()),
+		/**
+		* Converts a Maybe to a Validation.
+		* Some becomes Passed, None becomes Failed with error produced by `onNone`.
+		*
+		* @example
+		* ```ts
+		* pipe(Maybe.make.some(42), Maybe.to.Validation(() => "missing")); // Passed(42)
+		* pipe(Maybe.make.none(), Maybe.to.Validation(() => "missing"));   // Failed(["missing"])
+		* ```
+		*/
+		Validation: (onNone) => (data) => isSome(data) ? Validation.make.passed(data.value) : Validation.make.failed(onNone())
 	},
 	from: {
 		/**
@@ -763,19 +974,41 @@ const Maybe = {
 		Result: (data) => Result.is.ok(data) ? makeSome$1(data.value) : makeNone$1()
 	},
 	/**
+	* Wraps a synchronous operation that may throw, returning a `Maybe<A>`.
+	* Returns `Some(value)` if successful, or `None` if an exception is thrown.
+	*
+	* @example
+	* ```ts
+	* const safeParse = (s: string) => Maybe.tryCatch(() => JSON.parse(s));
+	* safeParse('{"a": 1}'); // Some({ a: 1 })
+	* safeParse('invalid');   // None
+	* ```
+	*/
+	tryCatch: (f) => {
+		try {
+			return makeSome$1(f());
+		} catch {
+			return makeNone$1();
+		}
+	},
+	/**
 	* Transforms the value inside a Maybe if it exists.
 	*
+	* @see {@link Maybe.chain} for functions that return a Maybe.
+	*
 	* @example
 	* ```ts
 	* pipe(Maybe.make.some(5), Maybe.map(n => n * 2)); // Some(10)
 	* pipe(Maybe.make.none(), Maybe.map(n => n * 2)); // None
 	* ```
 	*/
-	map: (f) => (data) => isSome(data) ? makeSome$1(f(data.value)) : data,
+	map: (transform) => (maybe) => isSome(maybe) ? makeSome$1(transform(maybe.value)) : maybe,
 	/**
-	* Chains Maybe computations. If the first is Some, passes the value to f.
+	* Chains Maybe computations. If the first is Some, passes the value to `transform`.
 	* If the first is None, propagates None.
 	*
+	* @see {@link Maybe.map} for transforming with plain non-optional functions.
+	*
 	* @example
 	* ```ts
 	* const parseNumber = (s: string): Maybe<number> => {
@@ -787,10 +1020,12 @@ const Maybe = {
 	* pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None
 	* ```
 	*/
-	chain: (f) => (data) => isSome(data) ? f(data.value) : data,
+	chain: (transform) => (maybe) => isSome(maybe) ? transform(maybe.value) : maybe,
 	/**
 	* Extracts the value from a Maybe by providing handlers for both cases.
 	*
+	* @see {@link Maybe.match} for named-case handling using an object.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -802,10 +1037,12 @@ const Maybe = {
 	* ); // "Value: 5"
 	* ```
 	*/
-	fold: (onNone, onSome) => (data) => isSome(data) ? onSome(data.value) : onNone(),
+	fold: (onNone, onSome) => (maybe) => isSome(maybe) ? onSome(maybe.value) : onNone(),
 	/**
 	* Pattern matches on a Maybe, returning the result of the matching case.
 	*
+	* @see {@link Maybe.fold} for positional arguments (onNone, onSome).
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -817,12 +1054,15 @@ const Maybe = {
 	* );
 	* ```
 	*/
-	match: (cases) => (data) => isSome(data) ? cases.some(data.value) : cases.none(),
+	match: (cases) => (maybe) => isSome(maybe) ? cases.some(maybe.value) : cases.none(),
 	/**
 	* Returns the value inside a Maybe, or a default value if None.
 	* The default is a thunk `() => B` — evaluated only when the Maybe is None.
 	* The default can be a different type, widening the result to `A | B`.
 	*
+	* @see {@link Maybe.match}
+	* @see {@link Maybe.to.nullable}
+	*
 	* @example
 	* ```ts
 	* pipe(Maybe.make.some(5), Maybe.getOrElse(() => 0)); // 5
@@ -830,11 +1070,13 @@ const Maybe = {
 	* pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
 	* ```
 	*/
-	getOrElse: (defaultValue) => (data) => isSome(data) ? data.value : defaultValue(),
+	getOrElse: (defaultValue) => (maybe) => isSome(maybe) ? maybe.value : defaultValue(),
 	/**
 	* Executes a side effect on the value without changing the Maybe.
 	* Useful for logging or debugging.
 	*
+	* @see {@link Maybe.tapNone} for running side effects on None.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -844,32 +1086,54 @@ const Maybe = {
 	* );
 	* ```
 	*/
-	tap: (f) => (data) => {
-		if (isSome(data)) f(data.value);
-		return data;
+	tap: (sideEffect) => (maybe) => {
+		if (isSome(maybe)) sideEffect(maybe.value);
+		return maybe;
+	},
+	/**
+	* Executes a side effect when the Maybe is None, without changing the Maybe.
+	*
+	* @see {@link Maybe.tap} for running side effects on Some.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Maybe.make.none(),
+	*   Maybe.tapNone(() => console.log("Value missing")),
+	* );
+	* ```
+	*/
+	tapNone: (sideEffect) => (maybe) => {
+		if (isNone(maybe)) sideEffect();
+		return maybe;
 	},
 	/**
-	* Filters a Maybe based on a predicate.
+	* Filters a Maybe based on a predicate or type guard.
 	* Returns None if the predicate returns false or if the Maybe is already None.
 	*
+	* @see {@link Maybe.map}
+	*
 	* @example
 	* ```ts
 	* pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
 	* pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
+	* pipe(Maybe.make.some("hi"), Maybe.filter((x): x is string => typeof x === "string")); // Some("hi")
 	* ```
 	*/
-	filter: (predicate) => (data) => isSome(data) ? predicate(data.value) ? data : makeNone$1() : data,
+	filter: ((predicate) => (maybe) => isSome(maybe) ? predicate(maybe.value) ? maybe : makeNone$1() : maybe),
 	/**
 	* Recovers from a None by providing a fallback Maybe.
 	* The fallback can produce a different type, widening the result to `Maybe<A | B>`.
 	*
+	* @see {@link Maybe.getOrElse}
+	*
 	* @example
 	* ```ts
 	* pipe(Maybe.make.none(), Maybe.recover(() => Maybe.make.some(42))); // Some(42)
 	* pipe(Maybe.make.some(10), Maybe.recover(() => Maybe.make.some(42))); // Some(10)
 	* ```
 	*/
-	recover: (fallback) => (data) => isSome(data) ? data : fallback(),
+	recover: (fallback) => (maybe) => isSome(maybe) ? maybe : fallback(),
 	/**
 	* Applies a function wrapped in a Maybe to a value wrapped in a Maybe.
 	*
@@ -878,12 +1142,12 @@ const Maybe = {
 	* const add = (a: number) => (b: number) => a + b;
 	* pipe(
 	*   Maybe.make.some(add),
-	*   Maybe.ap(Maybe.make.some(5)),
-	*   Maybe.ap(Maybe.make.some(3))
+	*   Maybe.apply(Maybe.make.some(5)),
+	*   Maybe.apply(Maybe.make.some(3))
 	* ); // Some(8)
 	* ```
 	*/
-	ap: (arg) => (data) => isSome(data) && isSome(arg) ? makeSome$1(data.value(arg.value)) : makeNone$1(),
+	apply: (arg) => (data) => isSome(data) && isSome(arg) ? makeSome$1(data.value(arg.value)) : makeNone$1(),
 	/**
 	* Converts a Maybe value into an object containing a single property.
 	* Initiates the pipeline accumulator record.
@@ -980,6 +1244,8 @@ const err = (error) => ({
 	error
 });
 const getMs$1 = (duration) => Duration.to.milliseconds(duration);
+const OP_FACTORY = Symbol.for("@nlozgachev/pipelined/Op.factory");
+const toInternalOp = (op) => op;
 /** Waits by the specified duration. Resolves early if the signal fires (non-blocking abort). */
 const cancellableWait = (duration, signal) => {
 	const rawMs = getMs$1(duration);
@@ -996,14 +1262,14 @@ const cancellableWait = (duration, signal) => {
 * Runs the factory with retry logic. Calls `onRetrying` before each retry delay.
 * Stops on Ok, Nil (null), abort, or exhausted attempts.
 */
-const runWithRetry = (op, input, signal, options, onRetrying) => {
+const runWithRetry = (op, args, signal, options, onRetrying) => {
 	const { attempts, backoff, when: shouldRetry } = options;
 	const getDelay = (n) => {
 		if (backoff === void 0) return;
 		return typeof backoff === "function" ? backoff(n) : backoff;
 	};
 	const attempt = async (left) => {
-		const result = await Deferred.to.Promise(op._factory(input, signal));
+		const result = await Deferred.to.Promise(toInternalOp(op)[OP_FACTORY](args, signal));
 		if (result === null || signal.aborted) return null;
 		if (result.kind === "Ok") return result;
 		if (left <= 1) return result;
@@ -1029,10 +1295,10 @@ const runWithRetry = (op, input, signal, options, onRetrying) => {
 * If the deadline fires, it aborts the `controller` and returns `Err(onTimeout())`.
 * A null result from the factory (signal aborted) becomes `_abortedNil`.
 */
-const execute = (op, input, controller, retryOptions, timeoutOptions, onRetrying) => {
+const execute = (op, args, controller, retryOptions, timeoutOptions, onRetrying) => {
 	const { signal } = controller;
 	const toOutcome = (r) => r === null ? _abortedNil : r.kind === "Ok" ? ok(r.value) : err(r.error);
-	const runPromise = retryOptions !== void 0 && onRetrying !== void 0 ? runWithRetry(op, input, signal, retryOptions, onRetrying).then(toOutcome) : Deferred.to.Promise(op._factory(input, signal)).then(toOutcome);
+	const runPromise = retryOptions !== void 0 && onRetrying !== void 0 ? runWithRetry(op, args, signal, retryOptions, onRetrying).then(toOutcome) : Deferred.to.Promise(toInternalOp(op)[OP_FACTORY](args, signal)).then(toOutcome);
 	if (timeoutOptions === void 0) return Deferred.from.Promise(runPromise);
 	let timerId;
 	return Deferred.from.Promise(Promise.race([runPromise.then((outcome) => {
@@ -1056,7 +1322,7 @@ const makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const run = (input) => Deferred.from.Promise(new Promise((resolve) => {
+	const run = (...args) => Deferred.from.Promise(new Promise((resolve) => {
 		waitController?.abort();
 		waitController = void 0;
 		currentController?.abort();
@@ -1069,7 +1335,7 @@ const makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
 			if (currentController !== controller) return;
 			lastStartTime = Date.now();
 			emit(_pending);
-			execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+			execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 				if (currentController === controller) emit(r);
 			} : void 0).then((outcome) => {
 				if (currentController !== controller) return;
@@ -1112,9 +1378,9 @@ const makeRestartable = (op, minInterval, retryOptions, timeoutOptions) => {
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1129,14 +1395,14 @@ const makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const run = (input) => {
+	const run = (...args) => {
 		if (currentController !== void 0 || cooldownTimer !== void 0) return Deferred.from.Promise(Promise.resolve(_droppedNil));
 		return Deferred.from.Promise(new Promise((resolve) => {
 			currentResolve = resolve;
 			currentController = new AbortController();
 			const controller = currentController;
 			emit(_pending);
-			execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+			execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 				if (currentController === controller) emit(r);
 			} : void 0).then((outcome) => {
 				if (currentController !== controller) return;
@@ -1178,9 +1444,9 @@ const makeExclusive = (op, cooldown, retryOptions, timeoutOptions) => {
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1198,13 +1464,13 @@ const makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, tim
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const startOne = (input, resolve, myGeneration) => {
+	const startOne = (args, resolve, myGeneration) => {
 		inFlight++;
 		const controller = new AbortController();
 		inflightControllers.add(controller);
 		inflightResolvers.push(resolve);
 		emit(_pending);
-		execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+		execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 			if (generation === myGeneration && inflightControllers.has(controller)) emit(r);
 		} : void 0).then((outcome) => {
 			inflightControllers.delete(controller);
@@ -1223,18 +1489,18 @@ const makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, tim
 			}
 		});
 	};
-	const run = (input) => {
+	const run = (...args) => {
 		const myGeneration = generation;
 		if (dedupe !== void 0) {
-			const idx = queue.findIndex((item) => dedupe(input, item.input));
+			const idx = queue.findIndex((item) => dedupe(args, item.input));
 			if (idx !== -1) queue.splice(idx, 1)[0].resolve(_droppedNil);
 		}
 		if (inFlight < maxConcurrency) return Deferred.from.Promise(new Promise((resolve) => {
-			startOne(input, resolve, myGeneration);
+			startOne(args, resolve, myGeneration);
 		}));
 		if (maxSize === void 0 || queue.length < maxSize) return Deferred.from.Promise(new Promise((resolve) => {
 			queue.push({
-				input,
+				input: args,
 				resolve
 			});
 			emit({
@@ -1245,7 +1511,7 @@ const makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, tim
 		if (overflow === "replace-last") return Deferred.from.Promise(new Promise((resolve) => {
 			queue.pop().resolve(_evictedNil);
 			queue.push({
-				input,
+				input: args,
 				resolve
 			});
 			emit({
@@ -1278,9 +1544,9 @@ const makeQueue = (op, maxSize, overflow, concurrency, dedupe, retryOptions, tim
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1296,12 +1562,12 @@ const makeBuffered = (op, size, retryOptions, timeoutOptions) => {
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const startRun = (input, resolve) => {
+	const startRun = (args, resolve) => {
 		currentResolve = resolve;
 		currentController = new AbortController();
 		const controller = currentController;
 		emit(_pending);
-		execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+		execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 			if (currentController === controller) emit(r);
 		} : void 0).then((outcome) => {
 			if (currentController !== controller) return;
@@ -1316,11 +1582,11 @@ const makeBuffered = (op, size, retryOptions, timeoutOptions) => {
 			}
 		});
 	};
-	const run = (input) => Deferred.from.Promise(new Promise((resolve) => {
-		if (currentController === void 0) startRun(input, resolve);
+	const run = (...args) => Deferred.from.Promise(new Promise((resolve) => {
+		if (currentController === void 0) startRun(args, resolve);
 		else if (buffer.length < bufferSize) {
 			buffer.push({
-				input,
+				input: args,
 				resolve
 			});
 			emit({
@@ -1330,7 +1596,7 @@ const makeBuffered = (op, size, retryOptions, timeoutOptions) => {
 		} else {
 			buffer.shift().resolve(_evictedNil);
 			buffer.push({
-				input,
+				input: args,
 				resolve
 			});
 			emit({
@@ -1361,9 +1627,9 @@ const makeBuffered = (op, size, retryOptions, timeoutOptions) => {
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1383,12 +1649,12 @@ const makeDebounced = (op, duration, leading, maxWait, retryOptions, timeoutOpti
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const fireLeading = (input, resolve) => {
+	const fireLeading = (args, resolve) => {
 		leadingController = new AbortController();
 		const controller = leadingController;
 		leadingResolve = resolve;
 		emit(_pending);
-		execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+		execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 			if (leadingController === controller) emit(r);
 		} : void 0).then((outcome) => {
 			if (leadingController !== controller) return;
@@ -1432,20 +1698,20 @@ const makeDebounced = (op, duration, leading, maxWait, retryOptions, timeoutOpti
 		timerId = setTimeout(fireTrailing, delay);
 	};
 	const inDebounceWindow = () => timerId !== void 0 || leadingController !== void 0 || currentController !== void 0;
-	const run = (input) => Deferred.from.Promise(new Promise((resolve) => {
+	const run = (...args) => Deferred.from.Promise(new Promise((resolve) => {
 		if (!inDebounceWindow()) {
 			firstCallAt = Date.now();
 			if (leading) {
-				fireLeading(input, resolve);
+				fireLeading(args, resolve);
 				scheduleTrailing();
 			} else {
-				pendingInput = input;
+				pendingInput = args;
 				pendingResolve = resolve;
 				scheduleTrailing();
 			}
 		} else {
 			const prev = pendingResolve;
-			pendingInput = input;
+			pendingInput = args;
 			pendingResolve = resolve;
 			prev?.(_evictedNil);
 			scheduleTrailing();
@@ -1485,9 +1751,9 @@ const makeDebounced = (op, duration, leading, maxWait, retryOptions, timeoutOpti
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1504,12 +1770,12 @@ const makeThrottled = (op, duration, trailing, retryOptions, timeoutOptions) =>
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const fireOp = (input, resolve) => {
+	const fireOp = (args, resolve) => {
 		currentResolve = resolve;
 		currentController = new AbortController();
 		const controller = currentController;
 		emit(_pending);
-		execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+		execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 			if (currentController === controller) emit(r);
 		} : void 0).then((outcome) => {
 			if (currentController !== controller) return;
@@ -1524,27 +1790,27 @@ const makeThrottled = (op, duration, trailing, retryOptions, timeoutOptions) =>
 		cooldownTimer = setTimeout(() => {
 			cooldownTimer = void 0;
 			if (trailing && pendingInput !== void 0) {
-				const input = pendingInput;
+				const toRun = pendingInput;
 				const resolve = pendingResolve;
 				pendingInput = void 0;
 				pendingResolve = void 0;
-				fireOp(input, resolve);
+				fireOp(toRun, resolve);
 				startCooldown();
 			}
 		}, getMs$1(duration));
 	};
-	const run = (input) => {
+	const run = (...args) => {
 		if (cooldownTimer !== void 0) {
 			if (!trailing) return Deferred.from.Promise(Promise.resolve(_droppedNil));
 			return Deferred.from.Promise(new Promise((resolve) => {
 				const prev = pendingResolve;
-				pendingInput = input;
+				pendingInput = args;
 				pendingResolve = resolve;
 				prev?.(_evictedNil);
 			}));
 		}
 		return Deferred.from.Promise(new Promise((resolve) => {
-			fireOp(input, resolve);
+			fireOp(args, resolve);
 			startCooldown();
 		}));
 	};
@@ -1576,9 +1842,9 @@ const makeThrottled = (op, duration, trailing, retryOptions, timeoutOptions) =>
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1595,13 +1861,13 @@ const makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const startOne = (input, resolve, myGeneration) => {
+	const startOne = (args, resolve, myGeneration) => {
 		inflight++;
 		const controller = new AbortController();
 		controllers.add(controller);
 		inflightResolvers.push(resolve);
 		emit(_pending);
-		execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+		execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 			if (generation === myGeneration && controllers.has(controller)) emit(r);
 		} : void 0).then((outcome) => {
 			controllers.delete(controller);
@@ -1620,15 +1886,15 @@ const makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
 			}
 		});
 	};
-	const run = (input) => {
+	const run = (...args) => {
 		const myGeneration = generation;
 		if (inflight < n) return Deferred.from.Promise(new Promise((resolve) => {
-			startOne(input, resolve, myGeneration);
+			startOne(args, resolve, myGeneration);
 		}));
 		if (overflow === "drop") return Deferred.from.Promise(Promise.resolve(_droppedNil));
 		return Deferred.from.Promise(new Promise((resolve) => {
 			overflowQueue.push({
-				input,
+				input: args,
 				resolve
 			});
 			emit({
@@ -1660,9 +1926,9 @@ const makeConcurrent = (op, n, overflow, retryOptions, timeoutOptions) => {
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1675,8 +1941,8 @@ const makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
 		const snapshot = new Map(stateMap);
 		subscribers.forEach((cb) => cb(snapshot));
 	};
-	const run = (input) => {
-		const k = keyFn(input);
+	const run = (...args) => {
+		const k = keyFn(...args);
 		if (slots.has(k)) {
 			if (perKey === "exclusive") return Deferred.from.Promise(Promise.resolve(_droppedNil));
 			const existing = slots.get(k);
@@ -1693,7 +1959,7 @@ const makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
 			});
 			stateMap.set(k, _pending);
 			emitSnapshot();
-			execute(op, input, controller, void 0, timeoutOptions).then((outcome) => {
+			execute(op, args, controller, void 0, timeoutOptions).then((outcome) => {
 				const slot = slots.get(k);
 				if (!slot || slot.controller !== controller) {
 					resolve(_abortedNil);
@@ -1744,9 +2010,9 @@ const makeKeyed = (op, keyFn, perKey, timeoutOptions) => {
 			stateMap.clear();
 			emitSnapshot();
 		},
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1760,14 +2026,14 @@ const makeOnce = (op, retryOptions, timeoutOptions) => {
 		currentState = state;
 		subscribers.forEach((cb) => cb(state));
 	};
-	const run = (input) => {
+	const run = (...args) => {
 		if (currentState.kind !== "Idle") return Deferred.from.Promise(Promise.resolve(_droppedNil));
 		return Deferred.from.Promise(new Promise((resolve) => {
 			currentResolve = resolve;
 			currentController = new AbortController();
 			const controller = currentController;
 			emit(_pending);
-			execute(op, input, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
+			execute(op, args, controller, retryOptions, timeoutOptions, retryOptions ? (r) => {
 				if (currentController === controller) emit(r);
 			} : void 0).then((outcome) => {
 				if (currentController !== controller) return;
@@ -1799,9 +2065,9 @@ const makeOnce = (op, retryOptions, timeoutOptions) => {
 			return () => subscribers.delete(cb);
 		},
 		reset: () => emit(_idle),
-		poll: (input, { interval }) => {
-			run(input);
-			const id = setInterval(() => void run(input), getMs$1(interval));
+		poll: ({ interval }) => (...args) => {
+			run(...args);
+			const id = setInterval(() => void run(...args), getMs$1(interval));
 			return () => clearInterval(id);
 		}
 	};
@@ -1838,7 +2104,7 @@ function interpretFn(op, options) {
 		case "debounced": return makeDebounced(op, options.duration, options.leading ?? false, options.maxWait, retryOptions, timeoutOptions);
 		case "throttled": return makeThrottled(op, options.duration, options.trailing ?? false, retryOptions, timeoutOptions);
 		case "concurrent": return makeConcurrent(op, options.n ?? 1, options.overflow ?? "drop", retryOptions, timeoutOptions);
-		case "keyed": return makeKeyed(op, options.key ?? ((i) => i), options.perKey ?? "exclusive", timeoutOptions);
+		case "keyed": return makeKeyed(op, options.key ?? ((...args) => args[0]), options.perKey ?? "exclusive", timeoutOptions);
 	}
 }
 const Op = {
@@ -1950,8 +2216,24 @@ const Op = {
 		*/
 		nil: isNil
 	},
-	create: (factory, onError) => ({ _factory: (input, signal) => Deferred.from.Promise(factory(signal)(input).then((value) => Result.make.ok(value)).catch((error) => signal.aborted ? null : Result.make.err(onError(error)))) }),
-	lift: (f) => Op.create((signal) => (input) => f(input, signal), (e) => e),
+	/**
+	* Creates an Op from a signal-accepting factory function that returns the async action,
+	* along with an error mapping handler.
+	*
+	* Arguments to the returned function are automatically inferred as tuple parameters via `Parameters<Fn>`.
+	*
+	* @example
+	* ```ts
+	* const fetchUser = Op.create(
+	*   (signal) => (id: string) => fetch(`/users/${id}`, { signal }).then(r => r.json() as Promise<User>),
+	*   { onError: (e) => new ApiError(e) },
+	* );
+	* ```
+	*/
+	create: (factory, options) => ({ [OP_FACTORY]: (args, signal) => Deferred.from.Promise((async () => {
+		return await factory(signal)(...args);
+	})().then((value) => Result.make.ok(value)).catch((error) => signal.aborted ? null : Result.make.err(options.onError(error)))) }),
+	lift: (f) => Op.create(f, { onError: (e) => e }),
 	match: (cases) => (outcome) => {
 		if (outcome.kind === "OpOk") return cases.ok(outcome.value);
 		if (outcome.kind === "OpErr") return cases.err(outcome.error);
@@ -2261,71 +2543,79 @@ const Ordering = {
 //#endregion
 //#region src/Core/Pair.ts
 const makePair = (first, second) => [first, second];
-const makeArray = (arr) => arr;
+const makeArray = (items) => items;
 const Pair = {
-	from: {
-		/**
-		* Creates a Pair from two values.
-		*
-		* @example
-		* ```ts
-		* Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
-		* ```
-		*/
-		pair: makePair,
-		/**
-		* Creates a Pair from a two-element array.
-		*
-		* @example
-		* ```ts
-		* Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
-		* ```
-		*/
-		array: makeArray
-	},
+	/**
+	* Creates a Pair from two values.
+	*
+	* @example
+	* ```ts
+	* Pair.make("Paris", 2_161_000); // ["Paris", 2161000]
+	* ```
+	*/
+	make: makePair,
+	from: { 
+	/**
+	* Creates a Pair from a two-element array.
+	*
+	* @example
+	* ```ts
+	* Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
+	* ```
+	*/
+array: makeArray },
 	/**
 	* Returns the first value from the pair.
 	*
 	* @example
 	* ```ts
-	* Pair.first(Pair.from.pair("Paris", 2_161_000)); // "Paris"
+	* Pair.first(Pair.make("Paris", 2_161_000)); // "Paris"
 	* ```
 	*/
-	first: (p) => p[0],
+	first: (pair) => pair[0],
 	/**
 	* Returns the second value from the pair.
 	*
 	* @example
 	* ```ts
-	* Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000
+	* Pair.second(Pair.make("Paris", 2_161_000)); // 2161000
 	* ```
 	*/
-	second: (p) => p[1],
+	second: (pair) => pair[1],
 	/**
 	* Transforms the first value, leaving the second unchanged.
 	*
+	* @see {@link Pair.mapSecond} to transform the second element instead.
+	* @see {@link Pair.mapBoth} to transform both elements at once.
+	*
 	* @example
 	* ```ts
-	* pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+	* pipe(Pair.make("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
 	* ```
 	*/
-	mapFirst: (f) => (p) => [f(p[0]), p[1]],
+	mapFirst: (transform) => (pair) => [transform(pair[0]), pair[1]],
 	/**
 	* Transforms the second value, leaving the first unchanged.
 	*
+	* @see {@link Pair.mapFirst} to transform the first element instead.
+	* @see {@link Pair.mapBoth} to transform both elements at once.
+	*
 	* @example
 	* ```ts
-	* pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
+	* pipe(Pair.make("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
 	* ```
 	*/
-	mapSecond: (f) => (p) => [p[0], f(p[1])],
+	mapSecond: (transform) => (pair) => [pair[0], transform(pair[1])],
 	/**
 	* Transforms both values independently in a single step.
 	*
+	* @see {@link Pair.mapFirst} to transform only the first element.
+	* @see {@link Pair.mapSecond} to transform only the second element.
+	*
 	* @example
 	* ```ts
 	* pipe(
-	*   Pair.from.pair("alice", 42),
+	*   Pair.make("alice", 42),
 	*   Pair.mapBoth(
 	*     (name) => name.toUpperCase(),
 	*     (score) => score * 2,
@@ -2333,37 +2623,37 @@ const Pair = {
 	* ); // ["ALICE", 84]
 	* ```
 	*/
-	mapBoth: (onFirst, onSecond) => (p) => [onFirst(p[0]), onSecond(p[1])],
+	mapBoth: (onFirst, onSecond) => (pair) => [onFirst(pair[0]), onSecond(pair[1])],
 	/**
 	* Applies a binary function to both values, collapsing the pair into a single value.
 	* Useful as the final step when consuming a pair in a pipeline.
 	*
 	* @example
 	* ```ts
-	* pipe(Pair.from.pair("Alice", 100), Pair.fold((name, score) => `${name}: ${score}`));
+	* pipe(Pair.make("Alice", 100), Pair.fold((name, score) => `${name}: ${score}`));
 	* // "Alice: 100"
 	* ```
 	*/
-	fold: (f) => (p) => f(p[0], p[1]),
+	fold: (reducer) => (pair) => reducer(pair[0], pair[1]),
 	/**
 	* Swaps the two values: `[A, B]` becomes `[B, A]`.
 	*
 	* @example
 	* ```ts
-	* Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]
+	* Pair.swap(Pair.make("key", 1)); // [1, "key"]
 	* ```
 	*/
-	swap: (p) => [p[1], p[0]],
+	swap: (pair) => [pair[1], pair[0]],
 	to: { 
 	/**
 	* Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
 	*
 	* @example
 	* ```ts
-	* Pair.to.Array(Pair.from.pair("hello", 42)); // ["hello", 42]
+	* Pair.to.array(Pair.make("hello", 42)); // ["hello", 42]
 	* ```
 	*/
-Array: (p) => [...p] },
+array: (pair) => [...pair] },
 	/**
 	* Runs a side effect with both values without changing the pair.
 	* Useful for logging or debugging in the middle of a pipeline.
@@ -2371,15 +2661,15 @@ Array: (p) => [...p] },
 	* @example
 	* ```ts
 	* pipe(
-	*   Pair.from.pair("Paris", 2_161_000),
+	*   Pair.make("Paris", 2_161_000),
 	*   Pair.tap((city, pop) => console.log(`${city}: ${pop}`)),
 	*   Pair.mapSecond((n) => n / 1_000_000),
 	* ); // logs "Paris: 2161000", returns ["Paris", 2.161]
 	* ```
 	*/
-	tap: (f) => (p) => {
-		f(p[0], p[1]);
-		return p;
+	tap: (sideEffect) => (pair) => {
+		sideEffect(pair[0], pair[1]);
+		return pair;
 	}
 };
 //#endregion
@@ -2622,12 +2912,12 @@ const Reader = {
 	* const add = (a: number) => (b: number) => a + b;
 	* pipe(
 	*   Reader.resolve<Config, typeof add>(add),
-	*   Reader.ap(Reader.asks(c => c.timeout)),
-	*   Reader.ap(Reader.resolve(5))
+	*   Reader.apply(Reader.asks(c => c.timeout)),
+	*   Reader.apply(Reader.resolve(5))
 	* )(appConfig);
 	* ```
 	*/
-	ap: (arg) => (data) => (env) => data(env)(arg(env)),
+	apply: (arg) => (data) => (env) => data(env)(arg(env)),
 	/**
 	* Executes a side effect on the produced value without changing the Reader.
 	* Useful for logging or debugging inside a pipeline.
@@ -2836,10 +3126,10 @@ const makeSuccess = (value) => ({
 	kind: "Success",
 	value
 });
-const isNotAsked = (data) => data.kind === "NotAsked";
-const isLoading = (data) => data.kind === "Loading";
-const isFailure = (data) => data.kind === "Failure";
-const isSuccess = (data) => data.kind === "Success";
+const isNotAsked = (remoteData) => remoteData.kind === "NotAsked";
+const isLoading = (remoteData) => remoteData.kind === "Loading";
+const isFailure = (remoteData) => remoteData.kind === "Failure";
+const isSuccess = (remoteData) => remoteData.kind === "Success";
 const RemoteData = {
 	make: {
 		/**
@@ -2907,6 +3197,8 @@ const RemoteData = {
 		/**
 		* Type guard that checks if a RemoteData is Failure.
 		*
+		* @see {@link RemoteData.is.success} to check if data loaded successfully.
+		*
 		* @example
 		* ```ts
 		* const data = RemoteData.make.failure("Failed");
@@ -2919,6 +3211,8 @@ const RemoteData = {
 		/**
 		* Type guard that checks if a RemoteData is Success.
 		*
+		* @see {@link RemoteData.is.failure} to check if data loading failed.
+		*
 		* @example
 		* ```ts
 		* const data = RemoteData.make.success(42);
@@ -2932,26 +3226,33 @@ const RemoteData = {
 	/**
 	* Transforms the success value inside a RemoteData.
 	*
+	* @see {@link RemoteData.chain} to sequence operations that themselves return a RemoteData.
+	* @see {@link RemoteData.mapError} to transform the error value instead of the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(RemoteData.make.success(5), RemoteData.map(n => n * 2)); // Success(10)
 	* pipe(RemoteData.make.loading(), RemoteData.map(n => n * 2)); // Loading
 	* ```
 	*/
-	map: (f) => (data) => isSuccess(data) ? makeSuccess(f(data.value)) : data,
+	map: (transform) => (remoteData) => isSuccess(remoteData) ? makeSuccess(transform(remoteData.value)) : remoteData,
 	/**
 	* Transforms the error value inside a RemoteData.
 	*
+	* @see {@link RemoteData.map} to transform the success value instead of the error value.
+	*
 	* @example
 	* ```ts
 	* pipe(RemoteData.make.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")
 	* ```
 	*/
-	mapError: (f) => (data) => isFailure(data) ? makeFailure(f(data.error)) : data,
+	mapError: (transform) => (remoteData) => isFailure(remoteData) ? makeFailure(transform(remoteData.error)) : remoteData,
 	/**
-	* Chains RemoteData computations. If the input is Success, passes the value to f.
+	* Chains RemoteData computations. If the input is Success, passes the value to transform.
 	* Otherwise, propagates the current state.
 	*
+	* @see {@link RemoteData.map} to transform the success value without returning a new RemoteData.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -2960,7 +3261,7 @@ const RemoteData = {
 	* );
 	* ```
 	*/
-	chain: (f) => (data) => isSuccess(data) ? f(data.value) : data,
+	chain: (transform) => (remoteData) => isSuccess(remoteData) ? transform(remoteData.value) : remoteData,
 	/**
 	* Applies a function wrapped in a RemoteData to a value wrapped in a RemoteData.
 	*
@@ -2969,27 +3270,29 @@ const RemoteData = {
 	* const add = (a: number) => (b: number) => a + b;
 	* pipe(
 	*   RemoteData.make.success(add),
-	*   RemoteData.ap(RemoteData.make.success(5)),
-	*   RemoteData.ap(RemoteData.make.success(3))
+	*   RemoteData.apply(RemoteData.make.success(5)),
+	*   RemoteData.apply(RemoteData.make.success(3))
 	* ); // Success(8)
 	* ```
 	*/
-	ap: (arg) => (data) => {
-		if (isSuccess(data) && isSuccess(arg)) return makeSuccess(data.value(arg.value));
-		if (isFailure(data)) return data;
+	apply: (arg) => (remoteData) => {
+		if (isSuccess(remoteData) && isSuccess(arg)) return makeSuccess(remoteData.value(arg.value));
+		if (isFailure(remoteData)) return remoteData;
 		if (isFailure(arg)) return arg;
-		if (isLoading(data) || isLoading(arg)) return makeLoading();
+		if (isLoading(remoteData) || isLoading(arg)) return makeLoading();
 		return makeNotAsked();
 	},
 	/**
 	* Extracts the value from a RemoteData by providing handlers for all four cases.
 	*
+	* @see {@link RemoteData.match} for named-case pattern matching with an object literal.
+	*
 	* @example
 	* ```ts
 	* pipe(
 	*   userData,
 	*   RemoteData.fold(
-	*     e => `Error: ${e}`,
+	*     error => `Error: ${error}`,
 	*     () => "Not asked",
 	*     () => "Loading...",
 	*     value => `Got: ${value}`
@@ -2997,17 +3300,19 @@ const RemoteData = {
 	* );
 	* ```
 	*/
-	fold: (onFailure, onNotAsked, onLoading, onSuccess) => (data) => {
-		switch (data.kind) {
-			case "Failure": return onFailure(data.error);
+	fold: (onFailure, onNotAsked, onLoading, onSuccess) => (remoteData) => {
+		switch (remoteData.kind) {
+			case "Failure": return onFailure(remoteData.error);
 			case "NotAsked": return onNotAsked();
 			case "Loading": return onLoading();
-			case "Success": return onSuccess(data.value);
+			case "Success": return onSuccess(remoteData.value);
 		}
 	},
 	/**
 	* Pattern matches on a RemoteData, returning the result of the matching case.
 	*
+	* @see {@link RemoteData.fold} for positional argument pattern matching.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -3015,24 +3320,26 @@ const RemoteData = {
 	*   RemoteData.match({
 	*     notAsked: () => "Click to load",
 	*     loading: () => "Loading...",
-	*     failure: e => `Error: ${e}`,
+	*     failure: error => `Error: ${error}`,
 	*     success: user => `Hello, ${user.name}!`
 	*   })
 	* );
 	* ```
 	*/
-	match: (cases) => (data) => {
-		switch (data.kind) {
+	match: (cases) => (remoteData) => {
+		switch (remoteData.kind) {
 			case "NotAsked": return cases.notAsked();
 			case "Loading": return cases.loading();
-			case "Failure": return cases.failure(data.error);
-			case "Success": return cases.success(data.value);
+			case "Failure": return cases.failure(remoteData.error);
+			case "Success": return cases.success(remoteData.value);
 		}
 	},
 	/**
 	* Returns the success value or a default value if the RemoteData is not Success.
 	* The default can be a different type, widening the result to `A | B`.
 	*
+	* @see {@link RemoteData.fold} to handle all four lifecycle states.
+	*
 	* @example
 	* ```ts
 	* pipe(RemoteData.make.success(5), RemoteData.getOrElse(() => 0)); // 5
@@ -3040,10 +3347,12 @@ const RemoteData = {
 	* pipe(RemoteData.make.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
 	* ```
 	*/
-	getOrElse: (defaultValue) => (data) => isSuccess(data) ? data.value : defaultValue(),
+	getOrElse: (fallback) => (remoteData) => isSuccess(remoteData) ? remoteData.value : fallback(),
 	/**
 	* Executes a side effect on the success value without changing the RemoteData.
 	*
+	* @see {@link RemoteData.tapError} to perform a side effect on the failure error.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -3053,14 +3362,16 @@ const RemoteData = {
 	* );
 	* ```
 	*/
-	tap: (f) => (data) => {
-		if (isSuccess(data)) f(data.value);
-		return data;
+	tap: (sideEffect) => (remoteData) => {
+		if (isSuccess(remoteData)) sideEffect(remoteData.value);
+		return remoteData;
 	},
 	/**
 	* Executes a side effect on the failure error without changing the RemoteData.
 	* Useful for logging errors.
 	*
+	* @see {@link RemoteData.tap} to perform a side effect on the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -3070,21 +3381,21 @@ const RemoteData = {
 	* );
 	* ```
 	*/
-	tapError: (f) => (data) => {
-		if (isFailure(data)) f(data.error);
-		return data;
+	tapError: (sideEffect) => (remoteData) => {
+		if (isFailure(remoteData)) sideEffect(remoteData.error);
+		return remoteData;
 	},
 	/**
 	* Recovers from a Failure state by providing a fallback RemoteData.
-	* The fallback can produce a different success type, widening the result to `RemoteData<E, A | B>`.
+	* The fallback can produce a different success type or resolve with a different error type.
 	*/
-	recover: (fallback) => (data) => isFailure(data) ? fallback(data.error) : data,
+	recover: (fallback) => (remoteData) => isFailure(remoteData) ? fallback(remoteData.error) : remoteData,
 	to: {
 		/**
 		* Converts a RemoteData to a Maybe.
 		* Success becomes Some, all other states become None.
 		*/
-		Maybe: (data) => isSuccess(data) ? Maybe.make.some(data.value) : Maybe.make.none(),
+		Maybe: (remoteData) => isSuccess(remoteData) ? Maybe.make.some(remoteData.value) : Maybe.make.none(),
 		/**
 		* Converts a RemoteData to a Result.
 		* Success becomes Ok, Failure becomes Err.
@@ -3098,7 +3409,7 @@ const RemoteData = {
 		* ); // Ok(42)
 		* ```
 		*/
-		Result: (onNotReady) => (data) => isSuccess(data) ? Result.make.ok(data.value) : Result.make.err(isFailure(data) ? data.error : onNotReady())
+		Result: (onNotReady) => (remoteData) => isSuccess(remoteData) ? Result.make.ok(remoteData.value) : Result.make.err(isFailure(remoteData) ? remoteData.error : onNotReady())
 	},
 	from: {
 		/**
@@ -3111,7 +3422,7 @@ const RemoteData = {
 		* setState(RemoteData.from.Result(result)); // Success(user) or Failure(msg)
 		* ```
 		*/
-		Result: (data) => Result.is.ok(data) ? makeSuccess(data.value) : makeFailure(data.error),
+		Result: (result) => Result.is.ok(result) ? makeSuccess(result.value) : makeFailure(result.error),
 		/**
 		* Converts a Maybe to a RemoteData.
 		* Some becomes Success, None becomes Failure using the onNone error producer.
@@ -3122,7 +3433,7 @@ const RemoteData = {
 		* pipe(Maybe.make.none(), RemoteData.from.Maybe(() => "not found"));     // Failure("not found")
 		* ```
 		*/
-		Maybe: (onNone) => (data) => Maybe.is.some(data) ? makeSuccess(data.value) : makeFailure(onNone())
+		Maybe: (onNone) => (maybe) => Maybe.is.some(maybe) ? makeSuccess(maybe.value) : makeFailure(onNone())
 	},
 	/**
 	* Filters a `Success` value. When the predicate passes, the value is kept. When it fails,
@@ -3137,7 +3448,7 @@ const RemoteData = {
 	* RemoteData.filter(n => n > 0, () => "error")(RemoteData.make.loading()); // Loading
 	* ```
 	*/
-	filter: (pred, onFalse) => (data) => isSuccess(data) ? pred(data.value) ? data : makeFailure(onFalse(data.value)) : data
+	filter: (predicate, onFalse) => (remoteData) => isSuccess(remoteData) ? predicate(remoteData.value) ? remoteData : makeFailure(onFalse(remoteData.value)) : remoteData
 };
 //#endregion
 //#region src/Core/Resource.ts
@@ -3145,7 +3456,7 @@ const makeHandlers = (acquire, release) => ({
 	acquire,
 	release
 });
-const makeTask = (acquire, release) => ({
+const makeTask$1 = (acquire, release) => ({
 	acquire: Task.map((a) => Result.make.ok(a))(acquire),
 	release
 });
@@ -3176,7 +3487,7 @@ const Resource = {
 		* );
 		* ```
 		*/
-		Task: makeTask
+		Task: makeTask$1
 	},
 	/**
 	* Acquires the resource, runs `f` with it, then releases it.
@@ -3239,12 +3550,12 @@ const makeOk$1 = (value) => ({
 	kind: "Ok",
 	value
 });
-const makeErr$1 = (e) => ({
+const makeErr$1 = (error) => ({
 	kind: "Err",
-	error: e
+	error
 });
-const isOk = (data) => data.kind === "Ok";
-const isErr = (data) => data.kind === "Err";
+const isOk = (result) => result.kind === "Ok";
+const isErr = (result) => result.kind === "Err";
 const Result = {
 	make: {
 		/**
@@ -3270,6 +3581,8 @@ const Result = {
 		/**
 		* Type guard that checks if a Result is Ok.
 		*
+		* @see {@link Result.is.err} to check if a Result is an Err failure.
+		*
 		* @example
 		* ```ts
 		* const res = Result.make.ok(42);
@@ -3282,6 +3595,8 @@ const Result = {
 		/**
 		* Type guard that checks if a Result is Err.
 		*
+		* @see {@link Result.is.ok} to check if a Result is an Ok success.
+		*
 		* @example
 		* ```ts
 		* const res = Result.make.err("failed");
@@ -3300,13 +3615,13 @@ const Result = {
 	* ```ts
 	* const result = Result.tryCatch(
 	*   () => JSON.parse(rawString),
-	*   { onError: (e) => `Parse error: ${e}` }
+	*   { onError: (error) => `Parse error: ${error}` }
 	* );
 	* ```
 	*/
-	tryCatch: (f, options) => {
+	tryCatch: (fn, options) => {
 		try {
-			return makeOk$1(f());
+			return makeOk$1(fn());
 		} catch (error) {
 			return makeErr$1(options.onError(error));
 		}
@@ -3314,26 +3629,33 @@ const Result = {
 	/**
 	* Transforms the success value inside a Result.
 	*
+	* @see {@link Result.chain} to sequence operations that themselves return a Result.
+	* @see {@link Result.mapError} to transform the error value instead of the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(Result.make.ok(5), Result.map(n => n * 2)); // Ok(10)
 	* pipe(Result.make.err("error"), Result.map(n => n * 2)); // Err("error")
 	* ```
 	*/
-	map: (f) => (data) => isOk(data) ? makeOk$1(f(data.value)) : data,
+	map: (transform) => (result) => isOk(result) ? makeOk$1(transform(result.value)) : result,
 	/**
 	* Transforms the error value inside a Result.
 	*
+	* @see {@link Result.map} to transform the success value instead of the error value.
+	*
 	* @example
 	* ```ts
 	* pipe(Result.make.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
 	* ```
 	*/
-	mapError: (f) => (data) => isErr(data) ? makeErr$1(f(data.error)) : data,
+	mapError: (transform) => (result) => isErr(result) ? makeErr$1(transform(result.error)) : result,
 	/**
-	* Chains Result computations. If the first is Ok, passes the value to f.
+	* Chains Result computations. If the first is Ok, passes the value to transform.
 	* If the first is Err, propagates the error.
 	*
+	* @see {@link Result.map} to transform the inner value without returning a new Result.
+	*
 	* @example
 	* ```ts
 	* const validatePositive = (n: number): Result<string, number> =>
@@ -3343,25 +3665,29 @@ const Result = {
 	* pipe(Result.make.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
 	* ```
 	*/
-	chain: (f) => (data) => isOk(data) ? f(data.value) : data,
+	chain: (transform) => (result) => isOk(result) ? transform(result.value) : result,
 	/**
 	* Extracts the value from a Result by providing handlers for both cases.
 	*
+	* @see {@link Result.match} for named-case pattern matching with an object literal.
+	*
 	* @example
 	* ```ts
 	* pipe(
 	*   Result.make.ok(5),
 	*   Result.fold(
-	*     e => `Error: ${e}`,
-	*     n => `Value: ${n}`
+	*     error => `Error: ${error}`,
+	*     value => `Value: ${value}`
 	*   )
 	* ); // "Value: 5"
 	* ```
 	*/
-	fold: (onErr, onOk) => (data) => isOk(data) ? onOk(data.value) : onErr(data.error),
+	fold: (onErr, onOk) => (result) => isOk(result) ? onOk(result.value) : onErr(result.error),
 	/**
 	* Pattern matches on a Result, returning the result of the matching case.
 	*
+	* @see {@link Result.fold} for positional argument pattern matching.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -3373,12 +3699,14 @@ const Result = {
 	* );
 	* ```
 	*/
-	match: (cases) => (data) => isOk(data) ? cases.ok(data.value) : cases.err(data.error),
+	match: (cases) => (result) => isOk(result) ? cases.ok(result.value) : cases.err(result.error),
 	/**
 	* Returns the success value or a default value if the Result is an error.
 	* The default is a thunk `() => B` — evaluated only when the Result is Err.
 	* The default can be a different type, widening the result to `A | B`.
 	*
+	* @see {@link Result.fold} to handle both the Ok and Err cases.
+	*
 	* @example
 	* ```ts
 	* pipe(Result.make.ok(5), Result.getOrElse(() => 0)); // 5
@@ -3386,11 +3714,13 @@ const Result = {
 	* pipe(Result.make.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
 	* ```
 	*/
-	getOrElse: (defaultValue) => (data) => isOk(data) ? data.value : defaultValue(),
+	getOrElse: (fallback) => (result) => isOk(result) ? result.value : fallback(),
 	/**
 	* Executes a side effect on the success value without changing the Result.
 	* Useful for logging or debugging.
 	*
+	* @see {@link Result.tapError} to perform a side effect on the error value.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -3400,14 +3730,16 @@ const Result = {
 	* );
 	* ```
 	*/
-	tap: (f) => (data) => {
-		if (isOk(data)) f(data.value);
-		return data;
+	tap: (sideEffect) => (result) => {
+		if (isOk(result)) sideEffect(result.value);
+		return result;
 	},
 	/**
 	* Executes a side effect on the error value without changing the Result.
 	* Useful for logging or reporting errors.
 	*
+	* @see {@link Result.tap} to perform a side effect on the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -3417,9 +3749,9 @@ const Result = {
 	* )
 	* ```
 	*/
-	tapError: (f) => (data) => {
-		if (isErr(data)) f(data.error);
-		return data;
+	tapError: (sideEffect) => (result) => {
+		if (isErr(result)) sideEffect(result.error);
+		return result;
 	},
 	from: {
 		/**
@@ -3433,7 +3765,7 @@ const Result = {
 		* pipe("", Result.from.Predicate(s => s.length > 0, () => "empty string")); // Err("empty string")
 		* ```
 		*/
-		Predicate: (pred, onFalse) => (a) => pred(a) ? makeOk$1(a) : makeErr$1(onFalse(a)),
+		Predicate: (predicate, onFalse) => (value) => predicate(value) ? makeOk$1(value) : makeErr$1(onFalse(value)),
 		/**
 		* Creates a Result from a nullable value.
 		* Returns Ok if the value is not null or undefined, error from onNull otherwise.
@@ -3465,16 +3797,20 @@ const Result = {
 		* Result.from.Validation((errors) => errors.join(", "))(Validation.make.failed("error1")); // Err("error1")
 		* ```
 		*/
-		Validation: (combineErrors) => (val) => Validation.is.passed(val) ? makeOk$1(val.value) : makeErr$1(combineErrors(val.errors))
+		Validation: (combineErrors) => (validation) => Validation.is.passed(validation) ? makeOk$1(validation.value) : makeErr$1(combineErrors(validation.errors))
 	},
 	/**
 	* Recovers from an error by providing a fallback Result.
-	* The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
+	* The fallback can produce a different success type or resolve with a different error type.
+	*
+	* @see {@link Result.recoverUnless} to conditionally recover based on the error value.
 	*/
-	recover: (fallback) => (data) => isOk(data) ? data : fallback(data.error),
+	recover: (fallback) => (result) => isOk(result) ? result : fallback(result.error),
 	/**
 	* Recovers from an error unless the predicate `isBlocked` returns true for that error.
-	* The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
+	* The fallback can produce a different success type, widening the result to `Result<E1 | E2, A | B>`.
+	*
+	* @see {@link Result.recover} for unconditional error recovery.
 	*
 	* @example
 	* ```ts
@@ -3484,7 +3820,7 @@ const Result = {
 	* ); // Ok(0)
 	* ```
 	*/
-	recoverUnless: (isBlocked, fallback) => (data) => isErr(data) && !isBlocked(data.error) ? fallback() : data,
+	recoverUnless: (isBlocked, fallback) => (result) => isErr(result) && !isBlocked(result.error) ? fallback(result.error) : result,
 	to: {
 		/**
 		* Converts a Result to a Maybe.
@@ -3496,7 +3832,7 @@ const Result = {
 		* Result.to.Maybe(Result.make.err("oops")); // None
 		* ```
 		*/
-		Maybe: (data) => isOk(data) ? Maybe.make.some(data.value) : Maybe.make.none(),
+		Maybe: (result) => isOk(result) ? Maybe.make.some(result.value) : Maybe.make.none(),
 		/**
 		* Converts a `Result` to a `Validation`. `Ok(a)` becomes `Passed(a)`; `Err(e)` becomes `Failed([e])`.
 		*
@@ -3506,7 +3842,7 @@ const Result = {
 		* Result.to.Validation(Result.make.err("bad")); // Failed(["bad"])
 		* ```
 		*/
-		Validation: (data) => Validation.from.Result(data)
+		Validation: (result) => Validation.from.Result(result)
 	},
 	/**
 	* Swaps the outer `Result` and inner `Maybe` context.
@@ -3519,7 +3855,7 @@ const Result = {
 	* Result.transposeMaybe(Result.make.err("error"));           // Some(Err("error"))
 	* ```
 	*/
-	transposeMaybe: (data) => isErr(data) ? Maybe.make.some(data) : Maybe.is.some(data.value) ? Maybe.make.some(makeOk$1(data.value.value)) : Maybe.make.none(),
+	transposeMaybe: (result) => isErr(result) ? Maybe.make.some(result) : Maybe.is.some(result.value) ? Maybe.make.some(makeOk$1(result.value.value)) : Maybe.make.none(),
 	/**
 	* Applies a function wrapped in a Result to a value wrapped in a Result.
 	*
@@ -3528,12 +3864,12 @@ const Result = {
 	* const add = (a: number) => (b: number) => a + b;
 	* pipe(
 	*   Result.make.ok(add),
-	*   Result.ap(Result.make.ok(5)),
-	*   Result.ap(Result.make.ok(3))
+	*   Result.apply(Result.make.ok(5)),
+	*   Result.apply(Result.make.ok(3))
 	* ); // Ok(8)
 	* ```
 	*/
-	ap: (arg) => (data) => isOk(data) && isOk(arg) ? makeOk$1(data.value(arg.value)) : isErr(data) ? data : arg,
+	apply: (arg) => (result) => isOk(result) && isOk(arg) ? makeOk$1(result.value(arg.value)) : isErr(result) ? result : arg,
 	/**
 	* Converts a Result value into an object containing a single property.
 	* Initiates the pipeline accumulator record.
@@ -3543,7 +3879,7 @@ const Result = {
 	* pipe(Result.make.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
 	* ```
 	*/
-	bindTo: (key) => (data) => isOk(data) ? makeOk$1({ [key]: data.value }) : data,
+	bindTo: (key) => (result) => isOk(result) ? makeOk$1({ [key]: result.value }) : result,
 	/**
 	* Evaluates a new Result using the current accumulator and attaches the output to a new key.
 	*
@@ -3555,11 +3891,11 @@ const Result = {
 	* ); // Ok({ a: 1, b: 2 })
 	* ```
 	*/
-	bind: (key, f) => (data) => {
-		if (!isOk(data)) return data;
-		const res = f(data.value);
+	bind: (key, transform) => (result) => {
+		if (!isOk(result)) return result;
+		const res = transform(result.value);
 		return isOk(res) ? makeOk$1({
-			...data.value,
+			...result.value,
 			[key]: res.value
 		}) : res;
 	},
@@ -3585,7 +3921,7 @@ const Result = {
 		return makeOk$1(result);
 	},
 	/**
-	* Narrows an `Ok` value with a predicate, converting to `Err(onFail(a))` if the predicate returns false.
+	* Narrows an `Ok` value with a predicate, converting to `Err(onFail(value))` if the predicate returns false.
 	*
 	* @example
 	* ```ts
@@ -3595,7 +3931,7 @@ const Result = {
 	* ); // Err("Age 15 is below 18")
 	* ```
 	*/
-	ensure: (predicate, onFail) => (data) => isErr(data) ? data : predicate(data.value) ? data : makeErr$1(onFail(data.value)),
+	ensure: (predicate, onFail) => (result) => isErr(result) ? result : predicate(result.value) ? result : makeErr$1(onFail(result.value)),
 	/**
 	* Transforms both branches of a Result simultaneously.
 	* Applies `onErr` to `Err` values and `onOk` to `Ok` values.
@@ -3611,7 +3947,7 @@ const Result = {
 	* ); // Ok(10)
 	* ```
 	*/
-	bimap: (onErr, onOk) => (data) => isOk(data) ? makeOk$1(onOk(data.value)) : makeErr$1(onErr(data.error))
+	bimap: (onErr, onOk) => (result) => isOk(result) ? makeOk$1(onOk(result.value)) : makeErr$1(onErr(result.error))
 };
 //#endregion
 //#region src/Core/State.ts
@@ -3724,14 +4060,14 @@ const State = {
 	* const addCounted = (n: number) => (m: number) => n + m;
 	* const program = pipe(
 	*   State.resolve<number, typeof addCounted>(addCounted),
-	*   State.ap(State.gets((s: number) => s * 2)),
-	*   State.ap(State.gets((s: number) => s)),
+	*   State.apply(State.gets((s: number) => s * 2)),
+	*   State.apply(State.gets((s: number) => s)),
 	* );
 	*
 	* State.evaluate(3)(program); // 6 + 3 = 9
 	* ```
 	*/
-	ap: (arg) => (fn) => (s) => {
+	apply: (arg) => (fn) => (s) => {
 		const [f, s1] = fn(s);
 		const [a, s2] = arg(s1);
 		return [f(a), s2];
@@ -3837,194 +4173,11 @@ const State = {
 	}
 };
 //#endregion
-//#region src/Core/Stream.ts
-const makeStream = (options) => ({
-	options,
-	_listeners: /* @__PURE__ */ new Set(),
-	_listenerArray: null,
-	_queue: [],
-	_isEmitting: false
-});
-const emitStream = (target, message) => {
-	const targets = Array.isArray(target) ? target : [target];
-	const msg = message;
-	for (const stream of targets) {
-		stream._queue.push(msg);
-		if (!stream._isEmitting) {
-			stream._isEmitting = true;
-			try {
-				while (stream._queue.length > 0) {
-					const nextMsg = stream._queue.shift();
-					if (stream._listenerArray === null) stream._listenerArray = Array.from(stream._listeners);
-					const listeners = stream._listenerArray;
-					for (const listener of listeners) try {
-						listener(nextMsg);
-					} catch (err) {
-						if (stream.options?.onError) stream.options.onError(err);
-						else throw err;
-					}
-				}
-			} finally {
-				stream._isEmitting = false;
-			}
-		}
-	}
-};
-const forwardStream = (options) => {
-	const targets = Array.isArray(options.to) ? options.to : [options.to];
-	const filterSet = options.only ? new Set(options.only) : null;
-	const handler = (msg) => {
-		if (filterSet !== null && !filterSet.has(msg.kind)) return;
-		for (const target of targets) emitStream(target, msg);
-	};
-	options.from._listeners.add(handler);
-	options.from._listenerArray = null;
-	return () => {
-		options.from._listeners.delete(handler);
-		options.from._listenerArray = null;
-	};
-};
-const listenStream = (stream, events, options) => {
-	const eventList = Array.isArray(events) ? events : [events];
-	const isOrdered = options?.ordered ?? false;
-	const isStrict = options?.strict ?? false;
-	const isOnce = options?.once ?? false;
-	const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
-	const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
-	const createMatcher = (onMatch) => {
-		let sequenceIndex = 0;
-		return (msg) => {
-			if (resetKinds !== null && resetKinds.has(msg.kind)) {
-				sequenceIndex = 0;
-				return;
-			}
-			if (!isOrdered) {
-				if (eventList.includes(msg.kind)) onMatch(msg);
-				return;
-			}
-			let expectedKind = eventList[sequenceIndex];
-			if (expectedKind !== msg.kind && optionalKinds !== null) {
-				let lookaheadIndex = sequenceIndex;
-				while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) lookaheadIndex++;
-				if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
-					sequenceIndex = lookaheadIndex;
-					expectedKind = eventList[sequenceIndex];
-				}
-			}
-			if (msg.kind === expectedKind) {
-				sequenceIndex++;
-				if (sequenceIndex === eventList.length) {
-					sequenceIndex = 0;
-					onMatch(msg);
-				}
-			} else if (isStrict) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
-			else if (eventList.includes(msg.kind)) sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
-		};
-	};
-	return {
-		reduce: (reducer, initialState) => {
-			let currentState = initialState;
-			const listenerFn = createMatcher((msg) => {
-				currentState = reducer(msg, currentState);
-				if (isOnce) {
-					stream._listeners.delete(listenerFn);
-					stream._listenerArray = null;
-				}
-			});
-			const unsubscribe = () => {
-				stream._listeners.delete(listenerFn);
-				stream._listenerArray = null;
-			};
-			stream._listeners.add(listenerFn);
-			stream._listenerArray = null;
-			return {
-				unsubscribe,
-				getState: () => currentState
-			};
-		},
-		tap: (effect) => {
-			const listenerFn = createMatcher((msg) => {
-				effect(msg);
-				if (isOnce) {
-					stream._listeners.delete(listenerFn);
-					stream._listenerArray = null;
-				}
-			});
-			const unsubscribe = () => {
-				stream._listeners.delete(listenerFn);
-				stream._listenerArray = null;
-			};
-			stream._listeners.add(listenerFn);
-			stream._listenerArray = null;
-			return unsubscribe;
-		}
-	};
-};
-const Stream = {
-	/**
-	* Constructs a new `Stream` instance.
-	*
-	* @example
-	* ```ts
-	* const stream = Stream.make<AppMessages>({ name: "app" });
-	* ```
-	*/
-	make: makeStream,
-	/**
-	* Emits a message payload to one or more target streams.
-	*
-	* Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
-	*
-	* @example
-	* ```ts
-	* Stream.emit(streamA, {
-	*   kind: "userLoggedIn",
-	*   value: { userId: "user-1" },
-	* });
-	*
-	* Stream.emit([streamA, streamB], {
-	*   kind: "userLoggedIn",
-	*   value: { userId: "user-1" },
-	* });
-	* ```
-	*/
-	emit: emitStream,
-	/**
-	* Forwards messages from one stream to another (or multiple).
-	*
-	* @example
-	* ```ts
-	* const stop = Stream.forward({
-	*   from: authStream,
-	*   to: analyticsStream,
-	*   only: ["userLoggedIn"],
-	* });
-	* ```
-	*/
-	forward: forwardStream,
-	/**
-	* Initiates listener registration on a stream for specific event kind(s) or sequence.
-	*
-	* @example
-	* ```ts
-	* const sub = Stream.listen(
-	*   appStream,
-	*   ["userLoggedIn", "checkoutStarted"],
-	*   { ordered: true }
-	* ).reduce(
-	*   (msg, state) => ({ count: state.count + 1 }),
-	*   { count: 0 }
-	* );
-	* ```
-	*/
-	listen: listenStream
-};
-//#endregion
 //#region src/Core/TaskMaybe.ts
-const makeSome = (value) => Task.resolve(Maybe.make.some(value));
-const makeNone = () => Task.resolve(Maybe.make.none());
-const mapTaskMaybe = (f) => (data) => Task.map(Maybe.map(f))(data);
-const chainTaskMaybe = (f) => (data) => Task.chain((option) => Maybe.is.some(option) ? f(option.value) : Task.resolve(Maybe.make.none()))(data);
+const makeSome = (value) => Task.make(Maybe.make.some(value));
+const makeNone = () => Task.make(Maybe.make.none());
+const mapTaskMaybe = (transform) => (task) => Task.map(Maybe.map(transform))(task);
+const chainTaskMaybe = (transform) => (task) => Task.chain((maybe) => Maybe.is.some(maybe) ? transform(maybe.value) : Task.make(Maybe.make.none()))(task);
 const TaskMaybe = {
 	/**
 	* Wraps a value in a Some inside a Task.
@@ -4066,7 +4219,7 @@ const TaskMaybe = {
 		* Task.Maybe.from.Maybe(Maybe.make.some(42));
 		* ```
 		*/
-		Maybe: (option) => Task.resolve(option),
+		Maybe: (maybe) => Task.make(maybe),
 		/**
 		* Creates a Task.Maybe from a nullable value.
 		* Returns Some if the value is not null or undefined, None otherwise.
@@ -4077,7 +4230,7 @@ const TaskMaybe = {
 		* Task.Maybe.from.nullable(null); // resolves to None
 		* ```
 		*/
-		nullable: (value) => Task.resolve(Maybe.from.nullable(value)),
+		nullable: (value) => Task.make(Maybe.from.nullable(value)),
 		/**
 		* Creates a Task.Maybe from a Result.
 		* Ok becomes Some, Error becomes None (the error value is discarded).
@@ -4088,7 +4241,7 @@ const TaskMaybe = {
 		* Task.Maybe.from.Result(Result.make.err("e")); // resolves to None
 		* ```
 		*/
-		Result: (result) => Task.resolve(Result.to.Maybe(result)),
+		Result: (result) => Task.make(Result.to.Maybe(result)),
 		/**
 		* Lifts a Task into a Task.Maybe by wrapping its result in Some.
 		*
@@ -4111,14 +4264,18 @@ const TaskMaybe = {
 	* );
 	* ```
 	*/
-	tryCatch: (f) => (signal) => Deferred.from.Promise(Promise.resolve(f(signal)).then(Maybe.make.some).catch(() => Maybe.make.none())),
+	tryCatch: (fn) => (signal) => Deferred.from.Promise(Promise.resolve(fn(signal)).then(Maybe.make.some).catch(() => Maybe.make.none())),
 	/**
 	* Transforms the value inside a Task.Maybe.
+	*
+	* @see {@link Task.Maybe.chain} to sequence operations that themselves return a Task.Maybe.
 	*/
 	map: mapTaskMaybe,
 	/**
 	* Chains Task.Maybe computations. If the first resolves to Some, passes the
-	* value to f. If the first resolves to None, propagates None.
+	* value to transform. If the first resolves to None, propagates None.
+	*
+	* @see {@link Task.Maybe.map} to transform the inner value without returning a new Task.Maybe.
 	*
 	* @example
 	* ```ts
@@ -4133,14 +4290,18 @@ const TaskMaybe = {
 	* Applies a function wrapped in a Task.Maybe to a value wrapped in a Task.Maybe.
 	* Both Tasks run in parallel.
 	*/
-	ap: (arg) => (data) => (signal) => Deferred.from.Promise(Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(([of_, oa]) => Maybe.ap(oa)(of_))),
+	apply: (arg) => (task) => (signal) => Deferred.from.Promise(Promise.all([Deferred.to.Promise(task(signal)), Deferred.to.Promise(arg(signal))]).then(([of_, oa]) => Maybe.apply(oa)(of_))),
 	/**
 	* Extracts a value from a Task.Maybe by providing handlers for both cases.
+	*
+	* @see {@link Task.Maybe.match} for named-case pattern matching with an object literal.
 	*/
-	fold: (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data),
+	fold: (onNone, onSome) => (task) => Task.map(Maybe.fold(onNone, onSome))(task),
 	/**
 	* Pattern matches on a Task.Maybe, returning a Task of the result.
 	*
+	* @see {@link Task.Maybe.fold} for positional argument pattern matching.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -4152,21 +4313,21 @@ const TaskMaybe = {
 	* )();
 	* ```
 	*/
-	match: (cases) => (data) => Task.map(Maybe.match(cases))(data),
+	match: (cases) => (task) => Task.map(Maybe.match(cases))(task),
 	/**
 	* Returns the value or a default if the Task.Maybe resolves to None.
 	* The default can be a different type, widening the result to `Task<A | B>`.
 	*/
-	getOrElse: (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data),
+	getOrElse: (fallback) => (task) => Task.map(Maybe.getOrElse(fallback))(task),
 	/**
 	* Executes a side effect on the value without changing the Task.Maybe.
 	* Useful for logging or debugging.
 	*/
-	tap: (f) => (data) => Task.map(Maybe.tap(f))(data),
+	tap: (sideEffect) => (task) => Task.map(Maybe.tap(sideEffect))(task),
 	/**
 	* Filters the value inside a Task.Maybe. Returns None if the predicate fails.
 	*/
-	filter: (predicate) => (data) => Task.map(Maybe.filter(predicate))(data),
+	filter: (predicate) => (task) => Task.map(Maybe.filter(predicate))(task),
 	to: { 
 	/**
 	* Converts a Task.Maybe to a Task.Result, using onNone to produce the error value.
@@ -4179,7 +4340,7 @@ const TaskMaybe = {
 	* );
 	* ```
 	*/
-Result: (onNone) => (data) => Task.map(Maybe.to.Result(onNone))(data) },
+Result: (onNone) => (task) => Task.map(Maybe.to.Result(onNone))(task) },
 	/**
 	* Lifts a Task.Maybe value into an accumulator object.
 	*
@@ -4188,7 +4349,7 @@ Result: (onNone) => (data) => Task.map(Maybe.to.Result(onNone))(data) },
 	* pipe(Task.Maybe.make.some(42), Task.Maybe.bindTo("value")); // Task.Maybe({ value: 42 })
 	* ```
 	*/
-	bindTo: (key) => (data) => mapTaskMaybe((a) => ({ [key]: a }))(data),
+	bindTo: (key) => (task) => mapTaskMaybe((value) => ({ [key]: value }))(task),
 	/**
 	* Evaluates a new Task.Maybe using the current accumulator and attaches the output to a new key.
 	*
@@ -4200,10 +4361,10 @@ Result: (onNone) => (data) => Task.map(Maybe.to.Result(onNone))(data) },
 	* ); // Task.Maybe({ a: 1, b: 2 })
 	* ```
 	*/
-	bind: (key, f) => (data) => chainTaskMaybe((a) => mapTaskMaybe((b) => ({
-		...a,
-		[key]: b
-	}))(f(a)))(data),
+	bind: (key, transform) => (task) => chainTaskMaybe((acc) => mapTaskMaybe((val) => ({
+		...acc,
+		[key]: val
+	}))(transform(acc)))(task),
 	/**
 	* Recovers from a None state by providing a fallback Task.Maybe.
 	*
@@ -4215,7 +4376,7 @@ Result: (onNone) => (data) => Task.map(Maybe.to.Result(onNone))(data) },
 	* ); // Task.Maybe(42)
 	* ```
 	*/
-	recover: (fallback) => (data) => Task.chain((maybe) => Maybe.is.none(maybe) ? fallback() : Task.resolve(maybe))(data),
+	recover: (fallback) => (task) => Task.chain((maybe) => Maybe.is.none(maybe) ? fallback() : Task.make(maybe))(task),
 	/**
 	* Combines a record of Task.Maybes into a single Task.Maybe of a record.
 	* Evaluates fields in parallel and returns None if any task resolves to None.
@@ -4254,10 +4415,10 @@ Result: (onNone) => (data) => Task.map(Maybe.to.Result(onNone))(data) },
 };
 //#endregion
 //#region src/Core/TaskResult.ts
-const makeOk = (value) => Task.resolve(Result.make.ok(value));
-const makeErr = (error) => Task.resolve(Result.make.err(error));
-const mapTaskResult = (f) => (data) => Task.map(Result.map(f))(data);
-const chainTaskResult = (f) => (data) => Task.chain((result) => Result.is.ok(result) ? f(result.value) : Task.resolve(Result.make.err(result.error)))(data);
+const makeOk = (value) => Task.make(Result.make.ok(value));
+const makeErr = (error) => Task.make(Result.make.err(error));
+const mapTaskResult = (transform) => (task) => Task.map(Result.map(transform))(task);
+const chainTaskResult = (transform) => (task) => Task.chain((result) => Result.is.ok(result) ? transform(result.value) : Task.make(Result.make.err(result.error)))(task);
 const TaskResult = {
 	make: {
 		/**
@@ -4292,7 +4453,7 @@ const TaskResult = {
 		* Task.Result.from.nullable(() => "missing")(null); // resolves to Err("missing")
 		* ```
 		*/
-		nullable: (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Result.make.err(onNull()) : Result.make.ok(value)),
+		nullable: (onNull) => (value) => Task.make(value === null || value === void 0 ? Result.make.err(onNull()) : Result.make.ok(value)),
 		/**
 		* Creates a Task.Result from a Maybe.
 		* Some becomes Ok, None becomes err from onNone.
@@ -4303,7 +4464,7 @@ const TaskResult = {
 		* Task.Result.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Err("empty")
 		* ```
 		*/
-		Maybe: (onNone) => (maybe) => Task.resolve(Maybe.is.none(maybe) ? Result.make.err(onNone()) : Result.make.ok(maybe.value)),
+		Maybe: (onNone) => (maybe) => Task.make(Maybe.is.none(maybe) ? Result.make.err(onNone()) : Result.make.ok(maybe.value)),
 		/**
 		* Lifts a Result into a Task.Result.
 		*
@@ -4312,7 +4473,7 @@ const TaskResult = {
 		* Task.Result.from.Result(Result.make.ok(42)); // resolves to Ok(42)
 		* ```
 		*/
-		Result: (result) => Task.resolve(result)
+		Result: (result) => Task.make(result)
 	},
 	to: { 
 	/**
@@ -4324,7 +4485,7 @@ const TaskResult = {
 	* const taskMaybe = pipe(taskResult, Task.Result.to.Maybe);
 	* ```
 	*/
-Maybe: (data) => Task.map(Result.to.Maybe)(data) },
+Maybe: (task) => Task.map(Result.to.Maybe)(task) },
 	/**
 	* Creates a Task.Result from a Promise-returning thunk that may throw or reject.
 	* Catches any errors and transforms them using the `onError` function into an `Err`.
@@ -4338,36 +4499,51 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* );
 	* ```
 	*/
-	tryCatch: (f, options) => (signal) => Deferred.from.Promise(globalThis.Promise.resolve().then(async () => f(signal)).then(Result.make.ok).catch((error) => Result.make.err(options.onError(error)))),
+	tryCatch: (fn, options) => (signal) => Deferred.from.Promise(globalThis.Promise.resolve().then(async () => fn(signal)).then(Result.make.ok).catch((error) => Result.make.err(options.onError(error)))),
 	/**
 	* Transforms the success value inside a Task.Result.
+	*
+	* @see {@link Task.Result.chain} to sequence operations that themselves return a Task.Result.
+	* @see {@link Task.Result.mapError} to transform the error value instead of the success value.
 	*/
 	map: mapTaskResult,
 	/**
 	* Transforms the error value inside a Task.Result.
+	*
+	* @see {@link Task.Result.map} to transform the success value instead of the error value.
 	*/
-	mapError: (f) => (data) => Task.map(Result.mapError(f))(data),
+	mapError: (transform) => (task) => Task.map(Result.mapError(transform))(task),
 	/**
-	* Chains Task.Result computations. If the first succeeds, passes the value to f.
+	* Chains Task.Result computations. If the first succeeds, passes the value to transform.
 	* If the first fails, propagates the error.
+	*
+	* @see {@link Task.Result.map} to transform the inner value without returning a new Task.Result.
 	*/
 	chain: chainTaskResult,
 	/**
 	* Extracts the value from a Task.Result by providing handlers for both cases.
+	*
+	* @see {@link Task.Result.match} for named-case pattern matching with an object literal.
 	*/
-	fold: (onErr, onOk) => (data) => Task.map(Result.fold(onErr, onOk))(data),
+	fold: (onErr, onOk) => (task) => Task.map(Result.fold(onErr, onOk))(task),
 	/**
 	* Pattern matches on a Task.Result, returning a Task of the result.
+	*
+	* @see {@link Task.Result.fold} for positional argument pattern matching.
 	*/
-	match: (cases) => (data) => Task.map(Result.match(cases))(data),
+	match: (cases) => (task) => Task.map(Result.match(cases))(task),
 	/**
 	* Recovers from an error by providing a fallback Task.Result.
-	* The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
+	* The fallback can produce a different success type or resolve with a different error type.
+	*
+	* @see {@link Task.Result.recoverUnless} to conditionally recover based on the error value.
 	*/
-	recover: (fallback) => (data) => Task.chain((result) => Result.is.err(result) ? fallback(result.error) : Task.resolve(result))(data),
+	recover: (fallback) => (task) => Task.chain((result) => Result.is.err(result) ? fallback(result.error) : Task.make(result))(task),
 	/**
 	* Recovers from an error unless the predicate `isBlocked` returns true for that error.
-	* The fallback can produce a different success type, widening the result to `Task.Result<E, A | B>`.
+	* The fallback can produce a different success type, widening the result to `Task.Result<E1 | E2, A | B>`.
+	*
+	* @see {@link Task.Result.recover} for unconditional error recovery.
 	*
 	* @example
 	* ```ts
@@ -4380,21 +4556,25 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* );
 	* ```
 	*/
-	recoverUnless: (isBlocked, fallback) => (data) => Task.chain((result) => Result.is.err(result) && !isBlocked(result.error) ? fallback(result.error) : Task.resolve(result))(data),
+	recoverUnless: (isBlocked, fallback) => (task) => Task.chain((result) => Result.is.err(result) && !isBlocked(result.error) ? fallback(result.error) : Task.make(result))(task),
 	/**
 	* Returns the success value or a default value if the Task.Result is an error.
 	* The default can be a different type, widening the result to `Task<A | B>`.
 	*/
-	getOrElse: (defaultValue) => (data) => Task.map(Result.getOrElse(defaultValue))(data),
+	getOrElse: (fallback) => (task) => Task.map(Result.getOrElse(fallback))(task),
 	/**
 	* Executes a side effect on the success value without changing the Task.Result.
 	* Useful for logging or debugging.
+	*
+	* @see {@link Task.Result.tapError} to perform a side effect on the error value.
 	*/
-	tap: (f) => (data) => Task.map(Result.tap(f))(data),
+	tap: (sideEffect) => (task) => Task.map(Result.tap(sideEffect))(task),
 	/**
 	* Executes a side effect on the error value without changing the Task.Result.
 	* Useful for logging or reporting async errors.
 	*
+	* @see {@link Task.Result.tap} to perform a side effect on the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -4404,12 +4584,12 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* )
 	* ```
 	*/
-	tapError: (f) => (data) => Task.map(Result.tapError(f))(data),
+	tapError: (sideEffect) => (task) => Task.map(Result.tapError(sideEffect))(task),
 	/**
 	* Applies a function wrapped in a Task.Result to a value wrapped in a Task.Result.
 	* Both Tasks run in parallel.
 	*/
-	ap: (arg) => (data) => (signal) => Deferred.from.Promise(Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(([of_, oa]) => Result.ap(oa)(of_))),
+	apply: (arg) => (task) => (signal) => Deferred.from.Promise(Promise.all([Deferred.to.Promise(task(signal)), Deferred.to.Promise(arg(signal))]).then(([of_, oa]) => Result.apply(oa)(of_))),
 	/**
 	* Executes a `Task.Result` with an optional signal, returning `Promise<Result<E, A>>`.
 	* Use as a terminal step in a `pipe` chain.
@@ -4435,7 +4615,7 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* pipe(Task.Result.make.ok(42), Task.Result.bindTo("value")); // Task.Result({ value: 42 })
 	* ```
 	*/
-	bindTo: (key) => (data) => mapTaskResult((a) => ({ [key]: a }))(data),
+	bindTo: (key) => (task) => mapTaskResult((value) => ({ [key]: value }))(task),
 	/**
 	* Evaluates a new Task.Result using the current accumulator and attaches the output to a new key.
 	*
@@ -4447,10 +4627,10 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* ); // Task.Result({ a: 1, b: 2 })
 	* ```
 	*/
-	bind: (key, f) => (data) => chainTaskResult((a) => mapTaskResult((b) => ({
-		...a,
-		[key]: b
-	}))(f(a)))(data),
+	bind: (key, transform) => (task) => chainTaskResult((acc) => mapTaskResult((val) => ({
+		...acc,
+		[key]: val
+	}))(transform(acc)))(task),
 	/**
 	* Combines a record of Task.Results into a single Task.Result of a record.
 	* Evaluates all tasks in parallel, forwarding the AbortSignal down to each sub-task.
@@ -4481,14 +4661,15 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* Retries a fallible Task.Result according to a RetryPolicy.
 	* If the task succeeds, returns Ok immediately.
 	* If the task fails, retries up to policy.attempts times with delays generated by policy.
+	* An optional `when` predicate selectively retries only specific errors (e.g. transient network errors).
 	*
 	* @example
 	* ```ts
 	* const policy = RetryPolicy.exponential({ attempts: 3, initial: Duration.milliseconds(100) });
-	* const retryableFetch = pipe(fetchData, Task.Result.retry(policy));
+	* const retryableFetch = pipe(fetchData, Task.Result.retry(policy, { when: (err) => isTransient(err) }));
 	* ```
 	*/
-	retry: (policy) => (task) => (signal) => Deferred.from.Promise((() => {
+	retry: (policy, options) => (task) => (signal) => Deferred.from.Promise((() => {
 		const { attempts } = policy;
 		const wait = (duration) => new Promise((res) => {
 			let timerId;
@@ -4496,10 +4677,7 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 				clearTimeout(timerId);
 				res();
 			};
-			if (signal) {
-				if (signal.aborted) return res();
-				signal.addEventListener("abort", onAbort, { once: true });
-			}
+			if (signal) signal.addEventListener("abort", onAbort, { once: true });
 			timerId = setTimeout(() => {
 				signal?.removeEventListener("abort", onAbort);
 				res();
@@ -4507,6 +4685,7 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 		});
 		const executeAttempt = (attempt) => Deferred.to.Promise(task(signal)).then((res) => {
 			if (Result.is.ok(res) || attempt >= attempts || signal?.aborted) return res;
+			if (options?.when && !options.when(res.error)) return res;
 			const delay = policy.getDelay(attempt);
 			return wait(delay).then(() => executeAttempt(attempt + 1));
 		});
@@ -4564,7 +4743,35 @@ Maybe: (data) => Task.map(Result.to.Maybe)(data) },
 	* // [Ok(val1), Err(err2), Ok(val3)]
 	* ```
 	*/
-	allSettled: (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal)))))
+	allSettled: (tasks) => (signal) => Deferred.from.Promise(Promise.all(tasks.map((task) => Deferred.to.Promise(task(signal))))),
+	/**
+	* Narrows the Ok value with a predicate. If the predicate returns false,
+	* converts the value to an Err using onFail.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Task.Result.make.ok(42),
+	*   Task.Result.ensure(n => n > 50, () => "too small")
+	* ); // Task.Result resolving to Err("too small")
+	* ```
+	*/
+	ensure: (predicate, onFail) => (task) => (signal) => Deferred.from.Promise(Deferred.to.Promise(task(signal)).then(Result.ensure(predicate, onFail))),
+	/**
+	* Maps both the Err and Ok channels simultaneously.
+	*
+	* @example
+	* ```ts
+	* pipe(
+	*   Task.Result.make.ok(42),
+	*   Task.Result.bimap(
+	*     (err: string) => new Error(err),
+	*     (n: number) => n * 2
+	*   )
+	* ); // Task.Result resolving to Ok(84)
+	* ```
+	*/
+	bimap: (onErr, onOk) => (task) => (signal) => Deferred.from.Promise(Deferred.to.Promise(task(signal)).then(Result.bimap(onErr, onOk)))
 };
 //#endregion
 //#region src/internal/InternalTypes.ts
@@ -4583,12 +4790,12 @@ const makeFailedAll$1 = (errors) => ({
 	kind: "Failed",
 	errors
 });
-const isPassed = (data) => data.kind === "Passed";
-const isFailed = (data) => data.kind === "Failed";
+const isPassed = (validation) => validation.kind === "Passed";
+const isFailed = (validation) => validation.kind === "Failed";
 function toResult(arg) {
 	if (typeof arg === "function") {
 		const combine = arg;
-		return (val) => isPassed(val) ? Result.make.ok(val.value) : Result.make.err(combine(val.errors));
+		return (validation) => isPassed(validation) ? Result.make.ok(validation.value) : Result.make.err(combine(validation.errors));
 	}
 	return isPassed(arg) ? Result.make.ok(arg.value) : Result.make.err(arg.errors);
 }
@@ -4626,6 +4833,8 @@ const Validation = {
 		/**
 		* Type guard that checks if a Validation is passed.
 		*
+		* @see {@link Validation.is.failed} to check if a Validation is failed.
+		*
 		* @example
 		* ```ts
 		* const v = Validation.make.passed(42);
@@ -4638,6 +4847,8 @@ const Validation = {
 		/**
 		* Type guard that checks if a Validation is failed.
 		*
+		* @see {@link Validation.is.passed} to check if a Validation is passed.
+		*
 		* @example
 		* ```ts
 		* const v = Validation.make.failed("invalid");
@@ -4656,13 +4867,13 @@ const Validation = {
 	* ```ts
 	* const result = Validation.tryCatch(
 	*   () => JSON.parse(rawString),
-	*   { onError: (e) => `Parse error: ${e}` }
+	*   { onError: (error) => `Parse error: ${error}` }
 	* );
 	* ```
 	*/
-	tryCatch: (f, options) => {
+	tryCatch: (fn, options) => {
 		try {
-			return makePassed$1(f());
+			return makePassed$1(fn());
 		} catch (error) {
 			return makeFailed$1(options.onError(error));
 		}
@@ -4683,7 +4894,7 @@ const Validation = {
 		* validateName("");      // Failed(["Name is required"])
 		* ```
 		*/
-		Predicate: (pred, onFalse) => (a) => pred(a) ? makePassed$1(a) : makeFailed$1(onFalse(a)),
+		Predicate: (predicate, onFalse) => (value) => predicate(value) ? makePassed$1(value) : makeFailed$1(onFalse(value)),
 		/**
 		* Creates a Validation from a nullable value.
 		* If the value is null or undefined, returns Failed with the error from onNull.
@@ -4720,69 +4931,74 @@ const Validation = {
 		* Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
 		* ```
 		*/
-		Result: (data) => data.kind === "Ok" ? makePassed$1(data.value) : makeFailed$1(data.error)
+		Result: (result) => result.kind === "Ok" ? makePassed$1(result.value) : makeFailed$1(result.error)
 	},
 	/**
 	* Transforms the success value inside a Validation.
 	*
+	* @see {@link Validation.mapError} to transform accumulated errors.
+	* @see {@link Validation.apply} to combine multiple validations.
+	*
 	* @example
 	* ```ts
 	* pipe(Validation.make.passed(5), Validation.map(n => n * 2)); // Passed(10)
 	* pipe(Validation.make.failed("oops"), Validation.map(n => n * 2)); // Failed(["oops"])
 	* ```
 	*/
-	map: (f) => (data) => isPassed(data) ? makePassed$1(f(data.value)) : data,
+	map: (transform) => (validation) => isPassed(validation) ? makePassed$1(transform(validation.value)) : validation,
 	/**
 	* Transforms the error list inside a Validation.
 	*
+	* @see {@link Validation.map} to transform the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(Validation.make.failed("oops"), Validation.mapError(e => e.toUpperCase())); // Failed(["OOPS"])
 	* ```
 	*/
-	mapError: (f) => (data) => isFailed(data) ? makeFailedAll$1(data.errors.map(f)) : data,
+	mapError: (transform) => (validation) => isFailed(validation) ? makeFailedAll$1(validation.errors.map(transform)) : validation,
 	/**
 	* Applies a function wrapped in a Validation to a value wrapped in a Validation.
-	* Accumulates errors from both sides.
+	* Accumulates errors from both sides if both fail, using optional `combineErrors`
+	* or default concatenation.
+	*
+	* @see {@link Validation.product} to combine two validations into a tuple.
 	*
 	* @example
 	* ```ts
 	* const add = (a: number) => (b: number) => a + b;
 	* pipe(
 	*   Validation.make.passed(add),
-	*   Validation.ap(Validation.make.passed(5)),
-	*   Validation.ap(Validation.make.passed(3))
+	*   Validation.apply(Validation.make.passed(5)),
+	*   Validation.apply(Validation.make.passed(3))
 	* ); // Passed(8)
 	*
 	* pipe(
 	*   Validation.make.passed(add),
-	*   Validation.ap(Validation.make.failed<string>("bad a")),
-	*   Validation.ap(Validation.make.failed<string>("bad b"))
+	*   Validation.apply(Validation.make.failed<string>("bad a")),
+	*   Validation.apply(Validation.make.failed<string>("bad b"))
 	* ); // Failed(["bad a", "bad b"])
-	* ```
-	*/
-	ap: (arg) => (data) => {
-		if (isPassed(data)) return isPassed(arg) ? makePassed$1(data.value(arg.value)) : makeFailedAll$1(arg.errors);
-		return isPassed(arg) ? makeFailedAll$1(data.errors) : makeFailedAll$1([...data.errors, ...arg.errors]);
-	},
-	/**
-	* Applies a function wrapped in a Validation to a value wrapped in a Validation,
-	* using a custom error concatenator function when both sides fail.
 	*
-	* @example
-	* ```ts
-	* const concat = (e1: NonEmptyArr<string>, e2: NonEmptyArr<string>): NonEmptyArr<string> =>
-	*   [...e1, ...e2];
-	* pipe(fnVal, Validation.apCustom(concat)(argVal));
+	* // Custom error combination:
+	* pipe(
+	*   Validation.make.passed(add),
+	*   Validation.apply(Validation.make.failed("err"), {
+	*     combineErrors: (e1, e2) => [...e1, ...e2],
+	*   })
+	* );
 	* ```
 	*/
-	apCustom: (concat) => (arg) => (data) => {
-		if (isPassed(data)) return isPassed(arg) ? makePassed$1(data.value(arg.value)) : makeFailedAll$1(arg.errors);
-		return isPassed(arg) ? makeFailedAll$1(data.errors) : makeFailedAll$1(concat(data.errors, arg.errors));
+	apply: (arg, options) => (validation) => {
+		if (isPassed(validation)) return isPassed(arg) ? makePassed$1(validation.value(arg.value)) : makeFailedAll$1(arg.errors);
+		if (isPassed(arg)) return makeFailedAll$1(validation.errors);
+		const combined = options?.combineErrors ? options.combineErrors(validation.errors, arg.errors) : [...validation.errors, ...arg.errors];
+		return makeFailedAll$1(combined);
 	},
 	/**
 	* Extracts the value from a Validation by providing handlers for both cases.
 	*
+	* @see {@link Validation.match} for named-case pattern matching with an object literal.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -4794,10 +5010,12 @@ const Validation = {
 	* );
 	* ```
 	*/
-	fold: (onFailed, onPassed) => (data) => isPassed(data) ? onPassed(data.value) : onFailed(data.errors),
+	fold: (onFailed, onPassed) => (validation) => isPassed(validation) ? onPassed(validation.value) : onFailed(validation.errors),
 	/**
 	* Pattern matches on a Validation, returning the result of the matching case.
 	*
+	* @see {@link Validation.fold} for positional argument pattern matching.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -4809,11 +5027,13 @@ const Validation = {
 	* );
 	* ```
 	*/
-	match: (cases) => (data) => isPassed(data) ? cases.passed(data.value) : cases.failed(data.errors),
+	match: (cases) => (validation) => isPassed(validation) ? cases.passed(validation.value) : cases.failed(validation.errors),
 	/**
 	* Returns the success value or a default value if the Validation is failed.
 	* The default can be a different type, widening the result to `A | B`.
 	*
+	* @see {@link Validation.fold} to handle both the passed and failed cases.
+	*
 	* @example
 	* ```ts
 	* pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
@@ -4821,10 +5041,12 @@ const Validation = {
 	* pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
 	* ```
 	*/
-	getOrElse: (defaultValue) => (data) => isPassed(data) ? data.value : defaultValue(),
+	getOrElse: (fallback) => (validation) => isPassed(validation) ? validation.value : fallback(),
 	/**
 	* Executes a side effect on the success value without changing the Validation.
 	*
+	* @see {@link Validation.tapError} to perform a side effect on accumulated errors.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -4834,14 +5056,16 @@ const Validation = {
 	* );
 	* ```
 	*/
-	tap: (f) => (data) => {
-		if (isPassed(data)) f(data.value);
-		return data;
+	tap: (sideEffect) => (validation) => {
+		if (isPassed(validation)) sideEffect(validation.value);
+		return validation;
 	},
 	/**
 	* Executes a side effect on the accumulated errors without changing the Validation.
 	* Useful for logging or reporting validation failures.
 	*
+	* @see {@link Validation.tap} to perform a side effect on the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -4851,19 +5075,23 @@ const Validation = {
 	* );
 	* ```
 	*/
-	tapError: (f) => (data) => {
-		if (isFailed(data)) f(data.errors);
-		return data;
+	tapError: (sideEffect) => (validation) => {
+		if (isFailed(validation)) sideEffect(validation.errors);
+		return validation;
 	},
 	/**
 	* Recovers from a Failed state by providing a fallback Validation.
 	* The fallback receives the accumulated error list so callers can inspect which errors occurred.
-	* The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+	* The fallback can produce a different success type or resolve with a different error type.
+	*
+	* @see {@link Validation.recoverUnless} to conditionally recover based on accumulated errors.
 	*/
-	recover: (fallback) => (data) => isPassed(data) ? data : fallback(data.errors),
+	recover: (fallback) => (validation) => isPassed(validation) ? validation : fallback(validation.errors),
 	/**
 	* Recovers from a Failed state unless `isBlocked` returns true for any of the accumulated errors.
-	* The fallback can produce a different success type, widening the result to `Validation<E, A | B>`.
+	* The fallback can produce a different success type, widening the result to `Validation<E1 | E2, A | B>`.
+	*
+	* @see {@link Validation.recover} for unconditional error recovery.
 	*
 	* @example
 	* ```ts
@@ -4873,7 +5101,7 @@ const Validation = {
 	* ); // Passed(0)
 	* ```
 	*/
-	recoverUnless: (isBlocked, fallback) => (data) => isFailed(data) && !data.errors.some(isBlocked) ? fallback() : data,
+	recoverUnless: (isBlocked, fallback) => (validation) => isFailed(validation) && !validation.errors.some(isBlocked) ? fallback(validation.errors) : validation,
 	to: {
 		/**
 		* Converts a Validation to a Result.
@@ -4899,13 +5127,16 @@ const Validation = {
 		* Validation.to.Maybe(Validation.make.failed("bad"));  // None
 		* ```
 		*/
-		Maybe: (data) => isPassed(data) ? Maybe.make.some(data.value) : Maybe.make.none()
+		Maybe: (validation) => isPassed(validation) ? Maybe.make.some(validation.value) : Maybe.make.none()
 	},
 	/**
 	* Combines two independent Validation instances into a tuple.
 	* If both are Passed, returns Passed with both values as a tuple.
 	* If either is Failed, accumulates errors from both sides.
 	*
+	* @see {@link Validation.productAll} to combine a non-empty list of validations.
+	* @see {@link Validation.apply} to apply a curried function across validations.
+	*
 	* @example
 	* ```ts
 	* Validation.product(
@@ -4928,6 +5159,8 @@ const Validation = {
 	* If all are Passed, returns Passed with all values collected into an array.
 	* If any are Failed, returns Failed with all accumulated errors.
 	*
+	* @see {@link Validation.product} to combine exactly two validations into a pair.
+	*
 	* @example
 	* ```ts
 	* Validation.productAll([
@@ -4938,10 +5171,10 @@ const Validation = {
 	* // Passed([name, email, age]) or Failed([...all errors])
 	* ```
 	*/
-	productAll: (data) => {
+	productAll: (validations) => {
 		const values = [];
 		const errors = [];
-		for (const v of data) if (isPassed(v)) values.push(v.value);
+		for (const v of validations) if (isPassed(v)) values.push(v.value);
 		else errors.push(...v.errors);
 		return isNonEmptyArr(errors) ? makeFailedAll$1(errors) : makePassed$1(values);
 	},
@@ -4971,13 +5204,116 @@ const Validation = {
 			else errors.push(...val.errors);
 		}
 		return isNonEmptyArr(errors) ? makeFailedAll$1(errors) : makePassed$1(record);
+	},
+	keyed: {
+		/**
+		* Creates a keyed validator function from a schema of field validators.
+		* Evaluates each validator against its corresponding field in the input object,
+		* returning a record where every key holds its own Validation outcome.
+		*
+		* @example
+		* ```ts
+		* const validateUser = Validation.keyed.make({
+		*   name: (s: string) => s.length > 0 ? Validation.make.passed(s) : Validation.make.failed("Name required"),
+		*   age: (n: number) => n >= 18 ? Validation.make.passed(n) : Validation.make.failed("Must be 18+"),
+		* });
+		*
+		* const result = validateUser({ name: "", age: 16 });
+		* // { name: Failed(["Name required"]), age: Failed(["Must be 18+"]) }
+		* ```
+		*/
+		make: (validators) => (input) => {
+			const out = {};
+			for (const key of Object.keys(validators)) out[key] = validators[key](input[key]);
+			return out;
+		},
+		is: {
+			/**
+			* Type guard checking if every keyed field is Passed.
+			*
+			* @see {@link Validation.keyed.is.failed} to check if any keyed field failed.
+			*
+			* @example
+			* ```ts
+			* if (Validation.keyed.is.passed(results)) {
+			*   // results.name is Passed<string>, results.age is Passed<number>
+			* }
+			* ```
+			*/
+			passed: (keyed) => {
+				for (const key of Object.keys(keyed)) if (keyed[key].kind !== "Passed") return false;
+				return true;
+			},
+			/**
+			* Checks if at least one keyed field is Failed.
+			*
+			* @see {@link Validation.keyed.is.passed} to check if all keyed fields passed.
+			*
+			* @example
+			* ```ts
+			* if (Validation.keyed.is.failed(results)) {
+			*   console.log("Validation errors occurred");
+			* }
+			* ```
+			*/
+			failed: (keyed) => {
+				for (const key of Object.keys(keyed)) if (keyed[key].kind === "Failed") return true;
+				return false;
+			}
+		},
+		/**
+		* Extracts all validated field values if every field passed.
+		* Returns `Some(data)` if all passed, `None` if any field failed.
+		*
+		* @see {@link Validation.keyed.getErrors} to extract keyed field errors when failures occur.
+		*
+		* @example
+		* ```ts
+		* const passed = Validation.keyed.getPassed(results);
+		* // Some({ name: "Alice", age: 30 }) or None
+		* ```
+		*/
+		getPassed: (keyed) => {
+			const out = {};
+			for (const key of Object.keys(keyed)) {
+				const v = keyed[key];
+				if (v.kind !== "Passed") return Maybe.make.none();
+				out[key] = v.value;
+			}
+			return Maybe.make.some(out);
+		},
+		/**
+		* Extracts keyed field errors if any field failed.
+		* Symmetrical to `getPassed`: returns `Some(errors)` when there are failures,
+		* or `None` if every field passed.
+		*
+		* @see {@link Validation.keyed.getPassed} to extract keyed values when all fields pass.
+		*
+		* @example
+		* ```ts
+		* const errors = Validation.keyed.getErrors(results);
+		* // Some({ name: ["Name required"] }) or None
+		* ```
+		*/
+		getErrors: (keyed) => {
+			let hasFailed = false;
+			const out = {};
+			for (const key of Object.keys(keyed)) {
+				const v = keyed[key];
+				if (v.kind === "Failed") {
+					hasFailed = true;
+					out[key] = v.errors;
+				}
+			}
+			return hasFailed ? Maybe.make.some(out) : Maybe.make.none();
+		}
 	}
 };
 //#endregion
 //#region src/Core/TaskValidation.ts
-const makePassed = (value) => Task.resolve(Validation.make.passed(value));
-const makeFailed = (error) => Task.resolve(Validation.make.failed(error));
-const makeFailedAll = (errors) => Task.resolve(Validation.make.failedAll(errors));
+const makePassed = (value) => Task.make(Validation.make.passed(value));
+const makeFailed = (error) => Task.make(Validation.make.failed(error));
+const makeFailedAll = (errors) => Task.make(Validation.make.failedAll(errors));
 const TaskValidation = {
 	make: {
 		/**
@@ -5020,7 +5356,7 @@ const TaskValidation = {
 		* Task.Validation.from.Validation(Validation.make.passed(42));
 		* ```
 		*/
-		Validation: (validation) => Task.resolve(validation),
+		Validation: (validation) => Task.make(validation),
 		/**
 		* Creates a Task.Validation from a nullable value.
 		* If the value is null or undefined, returns Failed with the error from onNull.
@@ -5032,7 +5368,7 @@ const TaskValidation = {
 		* Task.Validation.from.nullable(() => "missing")(null); // resolves to Failed(["missing"])
 		* ```
 		*/
-		nullable: (onNull) => (value) => Task.resolve(value === null || value === void 0 ? Validation.make.failed(onNull()) : Validation.make.passed(value)),
+		nullable: (onNull) => (value) => Task.make(value === null || value === void 0 ? Validation.make.failed(onNull()) : Validation.make.passed(value)),
 		/**
 		* Creates a Task.Validation from a Maybe.
 		* Some becomes Passed, None becomes Failed with the error from onNone.
@@ -5043,7 +5379,7 @@ const TaskValidation = {
 		* Task.Validation.from.Maybe(() => "empty")(Maybe.make.none());   // resolves to Failed(["empty"])
 		* ```
 		*/
-		Maybe: (onNone) => (maybe) => Task.resolve(Maybe.is.none(maybe) ? Validation.make.failed(onNone()) : Validation.make.passed(maybe.value)),
+		Maybe: (onNone) => (maybe) => Task.make(Maybe.is.none(maybe) ? Validation.make.failed(onNone()) : Validation.make.passed(maybe.value)),
 		/**
 		* Creates a Task.Validation from a Result.
 		* Ok becomes Passed, Err(e) becomes Failed([e]).
@@ -5054,7 +5390,7 @@ const TaskValidation = {
 		* Task.Validation.from.Result(Result.make.err("bad")); // resolves to Failed(["bad"])
 		* ```
 		*/
-		Result: (result) => Task.resolve(Validation.from.Result(result))
+		Result: (result) => Task.make(Validation.from.Result(result))
 	},
 	to: {
 		/**
@@ -5066,7 +5402,7 @@ const TaskValidation = {
 		* Task.Validation.to.Result((errors) => errors.join(", "))(validationTask);
 		* ```
 		*/
-		Result: (combineErrors) => (data) => Task.map(Validation.to.Result(combineErrors))(data),
+		Result: (combineErrors) => (task) => Task.map(Validation.to.Result(combineErrors))(task),
 		/**
 		* Converts a `Task.Validation` to a `Task.Maybe`.
 		* `Passed(a)` becomes `Some(a)`; `Failed(errors)` becomes `None` (errors are discarded).
@@ -5076,7 +5412,7 @@ const TaskValidation = {
 		* Task.Validation.to.Maybe(validationTask);
 		* ```
 		*/
-		Maybe: (data) => Task.map(Validation.to.Maybe)(data)
+		Maybe: (task) => Task.map(Validation.to.Maybe)(task)
 	},
 	/**
 	* Creates a Task.Validation from a Promise-returning thunk that may throw or reject.
@@ -5091,33 +5427,42 @@ const TaskValidation = {
 	* );
 	* ```
 	*/
-	tryCatch: (f, options) => (signal) => Deferred.from.Promise(globalThis.Promise.resolve().then(async () => f(signal)).then(Validation.make.passed).catch((error) => Validation.make.failed(options.onError(error)))),
+	tryCatch: (fn, options) => (signal) => Deferred.from.Promise(globalThis.Promise.resolve().then(async () => fn(signal)).then(Validation.make.passed).catch((error) => Validation.make.failed(options.onError(error)))),
 	/**
 	* Transforms the success value inside a Task.Validation.
+	*
+	* @see {@link Task.Validation.mapError} to transform accumulated errors.
+	* @see {@link Task.Validation.apply} to combine multiple validations in parallel.
 	*/
-	map: (f) => (data) => Task.map(Validation.map(f))(data),
+	map: (transform) => (task) => Task.map(Validation.map(transform))(task),
 	/**
 	* Applies a function wrapped in a Task.Validation to a value wrapped in a
 	* Task.Validation. Both Tasks run in parallel and errors from both sides
 	* are accumulated.
 	*
+	* @see {@link Task.Validation.product} to combine two validations into a tuple.
+	*
 	* @example
 	* ```ts
 	* pipe(
 	*   Task.Validation.make.passed((name: string) => (age: number) => ({ name, age })),
-	*   Task.Validation.ap(validateName(name)),
-	*   Task.Validation.ap(validateAge(age))
+	*   Task.Validation.apply(validateName(name)),
+	*   Task.Validation.apply(validateAge(age))
 	* )();
 	* ```
 	*/
-	ap: (arg) => (data) => (signal) => Deferred.from.Promise(Promise.all([Deferred.to.Promise(data(signal)), Deferred.to.Promise(arg(signal))]).then(([vf, va]) => Validation.ap(va)(vf))),
+	apply: (arg) => (task) => (signal) => Deferred.from.Promise(Promise.all([Deferred.to.Promise(task(signal)), Deferred.to.Promise(arg(signal))]).then(([vf, va]) => Validation.apply(va)(vf))),
 	/**
 	* Extracts a value from a Task.Validation by providing handlers for both cases.
+	*
+	* @see {@link Task.Validation.match} for named-case pattern matching with an object literal.
 	*/
-	fold: (onFailed, onPassed) => (data) => Task.map(Validation.fold(onFailed, onPassed))(data),
+	fold: (onFailed, onPassed) => (task) => Task.map(Validation.fold(onFailed, onPassed))(task),
 	/**
 	* Pattern matches on a Task.Validation, returning a Task of the result.
 	*
+	* @see {@link Task.Validation.fold} for positional argument pattern matching.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5129,26 +5474,32 @@ const TaskValidation = {
 	* )();
 	* ```
 	*/
-	match: (cases) => (data) => Task.map(Validation.match(cases))(data),
+	match: (cases) => (task) => Task.map(Validation.match(cases))(task),
 	/**
 	* Returns the success value or a default value if the Task.Validation is failed.
 	* The default can be a different type, widening the result to `Task<A | B>`.
 	*/
-	getOrElse: (defaultValue) => (data) => Task.map(Validation.getOrElse(defaultValue))(data),
+	getOrElse: (fallback) => (task) => Task.map(Validation.getOrElse(fallback))(task),
 	/**
 	* Executes a side effect on the success value without changing the Task.Validation.
 	* Useful for logging or debugging.
+	*
+	* @see {@link Task.Validation.tapError} to perform a side effect on accumulated errors.
 	*/
-	tap: (f) => (data) => Task.map(Validation.tap(f))(data),
+	tap: (sideEffect) => (task) => Task.map(Validation.tap(sideEffect))(task),
 	/**
 	* Recovers from a Failed state by providing a fallback Task.Validation.
 	* The fallback receives the accumulated error list so callers can inspect which errors occurred.
-	* The fallback can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
+	* The fallback can produce a different success type or resolve with a different error type.
+	*
+	* @see {@link Task.Validation.recoverUnless} to conditionally recover based on accumulated errors.
 	*/
-	recover: (fallback) => (data) => Task.chain((validation) => Validation.is.passed(validation) ? Task.resolve(validation) : fallback(validation.errors))(data),
+	recover: (fallback) => (task) => Task.chain((validation) => Validation.is.passed(validation) ? Task.make(validation) : fallback(validation.errors))(task),
 	/**
 	* Recovers from a Failed state unless the predicate `isBlocked` returns true for the accumulated errors.
-	* The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E, A | B>`.
+	* The fallback receives the accumulated errors and can produce a different success type, widening the result to `Task.Validation<E1 | E2, A | B>`.
+	*
+	* @see {@link Task.Validation.recover} for unconditional error recovery.
 	*
 	* @example
 	* ```ts
@@ -5161,12 +5512,15 @@ const TaskValidation = {
 	* );
 	* ```
 	*/
-	recoverUnless: (isBlocked, fallback) => (data) => Task.chain((validation) => Validation.is.passed(validation) ? Task.resolve(validation) : isBlocked(validation.errors) ? Task.resolve(validation) : fallback(validation.errors))(data),
+	recoverUnless: (isBlocked, fallback) => (task) => Task.chain((validation) => Validation.is.passed(validation) ? Task.make(validation) : isBlocked(validation.errors) ? Task.make(validation) : fallback(validation.errors))(task),
 	/**
 	* Runs two Task.Validations concurrently and combines their results into a tuple.
 	* If both are Passed, returns Passed with both values. If either fails, accumulates
 	* errors from both sides.
 	*
+	* @see {@link Task.Validation.productAll} to combine a list of validations.
+	* @see {@link Task.Validation.apply} to apply a curried function across validations.
+	*
 	* @example
 	* ```ts
 	* await Task.Validation.product(
@@ -5181,6 +5535,8 @@ const TaskValidation = {
 	* If all are Passed, returns Passed with all values as an array.
 	* If any fail, returns Failed with all accumulated errors.
 	*
+	* @see {@link Task.Validation.product} to combine two validations into a pair.
+	*
 	* @example
 	* ```ts
 	* await Task.Validation.productAll([
@@ -5190,13 +5546,15 @@ const TaskValidation = {
 	* ])(); // Passed([name, email, age]) or Failed([...all errors])
 	* ```
 	*/
-	productAll: (data) => (signal) => Deferred.from.Promise(Promise.all(data.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
+	productAll: (validations) => (signal) => Deferred.from.Promise(Promise.all(validations.map((t) => Deferred.to.Promise(t(signal)))).then((results) => {
 		const [first, ...rest] = results;
 		return Validation.productAll([first, ...rest]);
 	})),
 	/**
 	* Transforms all accumulated errors inside a Task.Validation.
 	*
+	* @see {@link Task.Validation.map} to transform the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5205,10 +5563,12 @@ const TaskValidation = {
 	* ); // Task.Validation(Failed(["OOPS"]))
 	* ```
 	*/
-	mapError: (f) => (data) => Task.map(Validation.mapError(f))(data),
+	mapError: (transform) => (task) => Task.map(Validation.mapError(transform))(task),
 	/**
 	* Executes a side effect on the accumulated errors without changing the Task.Validation.
 	*
+	* @see {@link Task.Validation.tap} to perform a side effect on the success value.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5217,7 +5577,7 @@ const TaskValidation = {
 	* );
 	* ```
 	*/
-	tapError: (f) => (data) => Task.map(Validation.tapError(f))(data),
+	tapError: (sideEffect) => (task) => Task.map(Validation.tapError(sideEffect))(task),
 	/**
 	* Combines a record of Task.Validations into a single Task.Validation of a record.
 	* Evaluates fields in parallel and accumulates all validation errors.
@@ -5260,23 +5620,23 @@ const TaskValidation = {
 const toPromise = (task, signal) => Deferred.to.Promise(task(signal));
 const fromPromise = (f) => (signal) => Deferred.from.Promise(f(signal));
 const getMs = (duration) => Duration.to.milliseconds(duration);
-const resolveTask = (value) => () => Deferred.from.Promise(globalThis.Promise.resolve(value));
-const syncTask = (f) => () => Deferred.from.Promise(globalThis.Promise.resolve(f()));
+const makeTask = (value) => () => Deferred.from.Promise(globalThis.Promise.resolve(value));
+const syncTask = (fn) => () => Deferred.from.Promise(globalThis.Promise.resolve(fn()));
 const Task = {
 	/**
 	* Creates a Task that immediately resolves to the given value.
 	*
 	* @example
 	* ```ts
-	* const task = Task.resolve(42);
+	* const task = Task.make(42);
 	* const value = await task(); // 42
 	* ```
 	*/
-	resolve: resolveTask,
+	make: makeTask,
 	from: { 
 	/**
 	* Creates a Task from a lazy synchronous thunk.
-	* Unlike `Task.resolve(f())`, `from.sync` does not evaluate `f` until the Task is called.
+	* Unlike `Task.make(f())`, `from.sync` does not evaluate `f` until the Task is called.
 	*
 	* @example
 	* ```ts
@@ -5297,10 +5657,12 @@ sync: syncTask },
 	* );
 	* ```
 	*/
-	tryCatch: (f, options) => fromPromise((signal) => globalThis.Promise.resolve().then(() => f(signal)).catch((err) => options.onError(err))),
+	tryCatch: (fn, options) => fromPromise((signal) => globalThis.Promise.resolve().then(() => fn(signal)).catch((err) => options.onError(err))),
 	/**
 	* Transforms the value inside a Task.
 	*
+	* @see {@link Task.chain} to sequence operations that return a Task.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5309,9 +5671,11 @@ sync: syncTask },
 	* )(); // Deferred<10>
 	* ```
 	*/
-	map: (f) => (data) => fromPromise((signal) => toPromise(data, signal).then(f)),
+	map: (transform) => (task) => fromPromise((signal) => toPromise(task, signal).then(transform)),
 	/**
-	* Chains Task computations. Passes the resolved value of the first Task to f.
+	* Chains Task computations. Passes the resolved value of the first Task to transform.
+	*
+	* @see {@link Task.map} to transform the resolved value without creating a new Task.
 	*
 	* @example
 	* ```ts
@@ -5325,22 +5689,24 @@ sync: syncTask },
 	* )(); // Deferred<Preferences>
 	* ```
 	*/
-	chain: (f) => (data) => fromPromise((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal))),
+	chain: (transform) => (task) => fromPromise((signal) => toPromise(task, signal).then((a) => toPromise(transform(a), signal))),
 	/**
 	* Applies a function wrapped in a Task to a value wrapped in a Task.
 	* Both Tasks run in parallel.
 	*
+	* @see {@link Task.all} to run multiple independent Tasks in parallel.
+	*
 	* @example
 	* ```ts
 	* const add = (a: number) => (b: number) => a + b;
 	* pipe(
-	*   Task.resolve(add),
-	*   Task.ap(Task.resolve(5)),
-	*   Task.ap(Task.resolve(3))
+	*   Task.make(add),
+	*   Task.apply(Task.make(5)),
+	*   Task.apply(Task.make(3))
 	* )(); // Deferred<8>
 	* ```
 	*/
-	ap: (arg) => (data) => fromPromise((signal) => Promise.all([toPromise(data, signal), toPromise(arg, signal)]).then(([f, a]) => f(a))),
+	apply: (arg) => (task) => fromPromise((signal) => Promise.all([toPromise(task, signal), toPromise(arg, signal)]).then(([f, a]) => f(a))),
 	/**
 	* Executes a side effect on the value without changing the Task.
 	* Useful for logging or debugging.
@@ -5354,20 +5720,42 @@ sync: syncTask },
 	* );
 	* ```
 	*/
-	tap: (f) => (data) => fromPromise((signal) => toPromise(data, signal).then((a) => {
-		f(a);
+	tap: (sideEffect) => (task) => fromPromise((signal) => toPromise(task, signal).then((a) => {
+		sideEffect(a);
 		return a;
 	})),
 	/**
 	* Runs multiple Tasks in parallel and collects their results.
+	* An optional `concurrency` option limits the number of tasks executing at any given time.
+	*
+	* @see {@link Task.sequence} to run an array of Tasks concurrently.
+	* @see {@link Task.sequential} to run an array of Tasks one after another in order.
 	*
 	* @example
 	* ```ts
 	* Task.all([loadConfig, detectLocale, loadTheme])();
 	* // Deferred<[Config, string, Theme]>
+	*
+	* Task.all([loadConfig, detectLocale, loadTheme], { concurrency: 2 })();
 	* ```
 	*/
-	all: (tasks) => fromPromise((signal) => Promise.all(tasks.map((t) => toPromise(t, signal)))),
+	all: (tasks, options) => fromPromise((signal) => {
+		const concurrency = options?.concurrency;
+		if (concurrency === void 0 || concurrency <= 0 || tasks.length <= concurrency) return Promise.all(tasks.map((t) => toPromise(t, signal)));
+		const len = tasks.length;
+		const results = new Array(len);
+		let nextIndex = 0;
+		const worker = async () => {
+			while (nextIndex < len) {
+				const currentIndex = nextIndex++;
+				results[currentIndex] = await toPromise(tasks[currentIndex], signal);
+			}
+		};
+		const workerCount = Math.min(concurrency, len);
+		const workers = [];
+		for (let i = 0; i < workerCount; i++) workers.push(worker());
+		return Promise.all(workers).then(() => results);
+	}),
 	/**
 	* Delays the execution of a Task by the specified duration.
 	* Useful for debouncing or rate limiting.
@@ -5375,30 +5763,32 @@ sync: syncTask },
 	* @example
 	* ```ts
 	* pipe(
-	*   Task.resolve(42),
+	*   Task.make(42),
 	*   Task.delay(Duration.seconds(1))
 	* )(); // Resolves after 1 second
 	* ```
 	*/
-	delay: (duration) => (data) => fromPromise((signal) => new Promise((res) => {
+	delay: (duration) => (task) => fromPromise((signal) => new Promise((res) => {
 		let timerId;
 		const onAbort = () => {
 			clearTimeout(timerId);
-			res(toPromise(data, signal));
+			res(toPromise(task, signal));
 		};
 		if (signal) {
-			if (signal.aborted) return res(toPromise(data, signal));
+			if (signal.aborted) return res(toPromise(task, signal));
 			signal.addEventListener("abort", onAbort, { once: true });
 		}
 		timerId = setTimeout(() => {
 			signal?.removeEventListener("abort", onAbort);
-			res(toPromise(data, signal));
+			res(toPromise(task, signal));
 		}, getMs(duration));
 	})),
 	/**
 	* Runs a Task a fixed number of times sequentially, collecting all results into an array.
 	* An optional delay duration can be inserted between runs.
 	*
+	* @see {@link Task.poll} to repeatedly run a Task until a predicate is satisfied.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5434,21 +5824,23 @@ sync: syncTask },
 		return run(times);
 	}),
 	/**
-	* Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-	* An optional delay duration can be inserted between runs.
-	* An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+	* Polls a Task repeatedly until the result satisfies a predicate, returning that result.
+	* An optional delay duration can be inserted between polling runs.
+	* An optional `attempts` cap stops the loop after N calls — the last value is returned
 	* regardless of whether the predicate was satisfied.
 	*
+	* @see {@link Task.repeat} to run a Task a fixed number of times.
+	*
 	* @example
 	* ```ts
 	* pipe(
 	*   checkStatus,
-	*   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
+	*   Task.poll({ until: (s) => s === "ready", delay: Duration.milliseconds(500) })
 	* )(); // polls every 500ms until status is "ready"
 	* ```
 	*/
-	repeatUntil: (options) => (task) => fromPromise((signal) => {
-		const { when: predicate, delay: delayDuration, maxAttempts } = options;
+	poll: (options) => (task) => fromPromise((signal) => {
+		const { until: predicate, delay: delayDuration, attempts } = options;
 		const wait = () => new Promise((r) => {
 			let timerId;
 			const onAbort = () => {
@@ -5465,7 +5857,7 @@ sync: syncTask },
 			if (signal?.aborted && lastValue !== void 0) return Promise.resolve(lastValue);
 			return toPromise(task, signal).then((a) => {
 				if (predicate(a)) return a;
-				if (maxAttempts !== void 0 && attempt >= maxAttempts) return a;
+				if (attempts !== void 0 && attempt >= attempts) return a;
 				if (signal?.aborted) return a;
 				return wait().then(() => run(attempt + 1, a));
 			});
@@ -5479,8 +5871,8 @@ sync: syncTask },
 	*
 	* @example
 	* ```ts
-	* const fast = Task.resolve("fast");
-	* const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
+	* const fast = Task.make("fast");
+	* const slow = Task.delay(Duration.milliseconds(200))(Task.make("slow"));
 	*
 	* await Task.race([fast, slow])(); // "fast"
 	* ```
@@ -5511,6 +5903,9 @@ sync: syncTask },
 	* Runs an array of Tasks concurrently and collects their results in an array.
 	* Forward-propagates the call site's AbortSignal to all subtasks concurrently.
 	*
+	* @see {@link Task.sequential} to run an array of tasks one after another in order.
+	* @see {@link Task.all} to run an array or tuple of tasks in parallel with optional concurrency limit.
+	*
 	* @example
 	* ```ts
 	* Task.sequence([loadConfig, detectLocale, loadTheme])();
@@ -5522,10 +5917,12 @@ sync: syncTask },
 	* Runs an array of Tasks one at a time in order, collecting all results.
 	* Each Task starts only after the previous one resolves.
 	*
+	* @see {@link Task.sequence} to run an array of tasks concurrently.
+	*
 	* @example
 	* ```ts
 	* let log: number[] = [];
-	* const makeTask = (n: number) => Task.resolve(n);
+	* const makeTask = (n: number) => Task.make(n);
 	*
 	* await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
 	* // log = [1, 2, 3] — tasks ran in order
@@ -5640,22 +6037,22 @@ sync: syncTask },
 	*
 	* @example
 	* ```ts
-	* pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
+	* pipe(Task.make(42), Task.bindTo("value")); // Task({ value: 42 })
 	* ```
 	*/
-	bindTo: (key) => (data) => fromPromise((signal) => toPromise(data, signal).then((a) => ({ [key]: a }))),
+	bindTo: (key) => (task) => fromPromise((signal) => toPromise(task, signal).then((a) => ({ [key]: a }))),
 	/**
 	* Evaluates a new Task using the current accumulator and attaches the output to a new key.
 	*
 	* @example
 	* ```ts
 	* pipe(
-	*   Task.resolve({ a: 1 }),
-	*   Task.bind("b", ({ a }) => Task.resolve(a + 1))
+	*   Task.make({ a: 1 }),
+	*   Task.bind("b", ({ a }) => Task.make(a + 1))
 	* ); // Task({ a: 1, b: 2 })
 	* ```
 	*/
-	bind: (key, f) => (data) => fromPromise((signal) => toPromise(data, signal).then((a) => toPromise(f(a), signal).then((b) => ({
+	bind: (key, transform) => (task) => fromPromise((signal) => toPromise(task, signal).then((a) => toPromise(transform(a), signal).then((b) => ({
 		...a,
 		[key]: b
 	})))),
@@ -5729,16 +6126,16 @@ const makeSecond = (value) => ({
 	kind: "Second",
 	second: value
 });
-const makeBoth = (f, s) => ({
+const makeBoth = (first, second) => ({
 	kind: "Both",
-	first: f,
-	second: s
+	first,
+	second
 });
-const isFirst = (data) => data.kind === "First";
-const isSecond = (data) => data.kind === "Second";
-const isBoth = (data) => data.kind === "Both";
-const hasFirst = (data) => data.kind === "First" || data.kind === "Both";
-const hasSecond = (data) => data.kind === "Second" || data.kind === "Both";
+const isFirst = (these) => these.kind === "First";
+const isSecond = (these) => these.kind === "Second";
+const isBoth = (these) => these.kind === "Both";
+const hasFirst = (these) => these.kind === "First" || these.kind === "Both";
+const hasSecond = (these) => these.kind === "Second" || these.kind === "Both";
 const These = {
 	make: {
 		/**
@@ -5810,6 +6207,8 @@ const These = {
 	/**
 	* Returns true if the These contains a first value (First or Both).
 	*
+	* @see {@link These.hasSecond} to check if These contains a second value.
+	*
 	* @example
 	* ```ts
 	* These.hasFirst(These.make.first(42));       // true
@@ -5821,6 +6220,8 @@ const These = {
 	/**
 	* Returns true if the These contains a second value (Second or Both).
 	*
+	* @see {@link These.hasFirst} to check if These contains a first value.
+	*
 	* @example
 	* ```ts
 	* These.hasSecond(These.make.second("warn"));  // true
@@ -5832,6 +6233,9 @@ const These = {
 	/**
 	* Transforms the first value, leaving the second unchanged.
 	*
+	* @see {@link These.mapSecond} to transform the second element.
+	* @see {@link These.mapBoth} to transform both elements.
+	*
 	* @example
 	* ```ts
 	* pipe(These.make.first(5), These.mapFirst(n => n * 2));           // First(10)
@@ -5839,28 +6243,34 @@ const These = {
 	* pipe(These.make.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
 	* ```
 	*/
-	mapFirst: (f) => (data) => {
-		if (isSecond(data)) return data;
-		if (isFirst(data)) return makeFirst(f(data.first));
-		return makeBoth(f(data.first), data.second);
+	mapFirst: (transform) => (these) => {
+		if (isSecond(these)) return these;
+		if (isFirst(these)) return makeFirst(transform(these.first));
+		return makeBoth(transform(these.first), these.second);
 	},
 	/**
 	* Transforms the second value, leaving the first unchanged.
 	*
+	* @see {@link These.mapFirst} to transform the first element.
+	* @see {@link These.mapBoth} to transform both elements.
+	*
 	* @example
 	* ```ts
 	* pipe(These.make.second("warn"), These.mapSecond(e => e.toUpperCase()));     // Second("WARN")
 	* pipe(These.make.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
 	* ```
 	*/
-	mapSecond: (f) => (data) => {
-		if (isFirst(data)) return data;
-		if (isSecond(data)) return makeSecond(f(data.second));
-		return makeBoth(data.first, f(data.second));
+	mapSecond: (transform) => (these) => {
+		if (isFirst(these)) return these;
+		if (isSecond(these)) return makeSecond(transform(these.second));
+		return makeBoth(these.first, transform(these.second));
 	},
 	/**
 	* Transforms both the first and second values independently.
 	*
+	* @see {@link These.mapFirst} to transform only the first element.
+	* @see {@link These.mapSecond} to transform only the second element.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5869,14 +6279,16 @@ const These = {
 	* ); // Both(10, "WARN")
 	* ```
 	*/
-	mapBoth: (onFirst, onSecond) => (data) => {
-		if (isSecond(data)) return makeSecond(onSecond(data.second));
-		if (isFirst(data)) return makeFirst(onFirst(data.first));
-		return makeBoth(onFirst(data.first), onSecond(data.second));
+	mapBoth: (onFirst, onSecond) => (these) => {
+		if (isSecond(these)) return makeSecond(onSecond(these.second));
+		if (isFirst(these)) return makeFirst(onFirst(these.first));
+		return makeBoth(onFirst(these.first), onSecond(these.second));
 	},
 	/**
-	* Chains These computations by passing the first value to f.
-	* Second propagates unchanged; First and Both apply f to the first value.
+	* Chains These computations by passing the first value to transform.
+	* Second propagates unchanged; First and Both apply transform to the first value.
+	*
+	* @see {@link These.chainSecond} to chain based on the second value.
 	*
 	* @example
 	* ```ts
@@ -5887,13 +6299,15 @@ const These = {
 	* pipe(These.make.second("warn"), These.chainFirst(double));      // Second("warn")
 	* ```
 	*/
-	chainFirst: (f) => (data) => {
-		if (isSecond(data)) return data;
-		return f(data.first);
+	chainFirst: (transform) => (these) => {
+		if (isSecond(these)) return these;
+		return transform(these.first);
 	},
 	/**
-	* Chains These computations by passing the second value to f.
-	* First propagates unchanged; Second and Both apply f to the second value.
+	* Chains These computations by passing the second value to transform.
+	* First propagates unchanged; Second and Both apply transform to the second value.
+	*
+	* @see {@link These.chainFirst} to chain based on the first value.
 	*
 	* @example
 	* ```ts
@@ -5904,13 +6318,15 @@ const These = {
 	* pipe(These.make.first(5), These.chainSecond(shout));            // First(5)
 	* ```
 	*/
-	chainSecond: (f) => (data) => {
-		if (isFirst(data)) return data;
-		return f(data.second);
+	chainSecond: (transform) => (these) => {
+		if (isFirst(these)) return these;
+		return transform(these.second);
 	},
 	/**
 	* Extracts a value from a These by providing handlers for all three cases.
 	*
+	* @see {@link These.match} for named-case pattern matching with an object literal.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5923,14 +6339,16 @@ const These = {
 	* );
 	* ```
 	*/
-	fold: (onFirst, onSecond, onBoth) => (data) => {
-		if (isSecond(data)) return onSecond(data.second);
-		if (isFirst(data)) return onFirst(data.first);
-		return onBoth(data.first, data.second);
+	fold: (onFirst, onSecond, onBoth) => (these) => {
+		if (isSecond(these)) return onSecond(these.second);
+		if (isFirst(these)) return onFirst(these.first);
+		return onBoth(these.first, these.second);
 	},
 	/**
 	* Pattern matches on a These, returning the result of the matching case.
 	*
+	* @see {@link These.fold} for positional argument pattern matching.
+	*
 	* @example
 	* ```ts
 	* pipe(
@@ -5943,15 +6361,17 @@ const These = {
 	* );
 	* ```
 	*/
-	match: (cases) => (data) => {
-		if (isSecond(data)) return cases.second(data.second);
-		if (isFirst(data)) return cases.first(data.first);
-		return cases.both(data.first, data.second);
+	match: (cases) => (these) => {
+		if (isSecond(these)) return cases.second(these.second);
+		if (isFirst(these)) return cases.first(these.first);
+		return cases.both(these.first, these.second);
 	},
 	/**
 	* Returns the first value, or a default if the These has no first value.
 	* The default can be a different type, widening the result to `A | C`.
 	*
+	* @see {@link These.getSecondOrElse} to retrieve the second value with fallback.
+	*
 	* @example
 	* ```ts
 	* pipe(These.make.first(5), These.getFirstOrElse(() => 0));            // 5
@@ -5960,11 +6380,13 @@ const These = {
 	* pipe(These.make.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
 	* ```
 	*/
-	getFirstOrElse: (defaultValue) => (data) => hasFirst(data) ? data.first : defaultValue(),
+	getFirstOrElse: (fallback) => (these) => hasFirst(these) ? these.first : fallback(),
 	/**
 	* Returns the second value, or a default if the These has no second value.
 	* The default can be a different type, widening the result to `B | D`.
 	*
+	* @see {@link These.getFirstOrElse} to retrieve the first value with fallback.
+	*
 	* @example
 	* ```ts
 	* pipe(These.make.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
@@ -5973,7 +6395,7 @@ const These = {
 	* pipe(These.make.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
 	* ```
 	*/
-	getSecondOrElse: (defaultValue) => (data) => hasSecond(data) ? data.second : defaultValue(),
+	getSecondOrElse: (fallback) => (these) => hasSecond(these) ? these.second : fallback(),
 	/**
 	* Runs a side effect on the first value without changing the These.
 	* Useful for logging or debugging.
@@ -5983,9 +6405,9 @@ const These = {
 	* pipe(These.make.first(5), These.tap(console.log)); // logs 5, returns First(5)
 	* ```
 	*/
-	tap: (f) => (data) => {
-		if (hasFirst(data)) f(data.first);
-		return data;
+	tap: (sideEffect) => (these) => {
+		if (hasFirst(these)) sideEffect(these.first);
+		return these;
 	},
 	/**
 	* Swaps the roles of first and second values.
@@ -6000,11 +6422,11 @@ const These = {
 	* These.swap(These.make.both(5, "warn"));     // Both("warn", 5)
 	* ```
 	*/
-	swap: (data) => {
-		if (isSecond(data)) return makeFirst(data.second);
-		if (isFirst(data)) return makeSecond(data.first);
-		return makeBoth(data.second, data.first);
+	swap: (these) => {
+		if (isSecond(these)) return makeFirst(these.second);
+		if (isFirst(these)) return makeSecond(these.first);
+		return makeBoth(these.second, these.first);
 	}
 };
 //#endregion
-export { Combinable as C, Deferred as S, Maybe as _, Stream as a, Lazy as b, Resource as c, Reader as d, Predicate as f, Op as g, Optional as h, isNonEmptyArr as i, RemoteData as l, Ordering as m, Task as n, State as o, Pair as p, Validation as r, Result as s, These as t, Refinement as u, Logged as v, Equality as x, Lens as y };
+export { Combinable as C, Deferred as S, Logged as _, State as a, EventBus as b, RemoteData as c, Predicate as d, Pair as f, Maybe as g, Op as h, isNonEmptyArr as i, Refinement as l, Optional as m, Task as n, Result as o, Ordering as p, Validation as r, Resource as s, These as t, Reader as u, Lens as v, Equality as x, Lazy as y };