@nlozgachev/pipelined 0.66.0 → 0.67.0

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

@@ -667,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.
@@ -731,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]
 	}),
@@ -845,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);
@@ -857,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();
@@ -905,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: {
 		/**
@@ -966,17 +994,21 @@ const Maybe = {
 	/**
 	* 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> => {
@@ -988,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(
@@ -1003,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(
@@ -1018,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
@@ -1031,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(
@@ -1045,13 +1086,15 @@ 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(
@@ -1060,14 +1103,16 @@ const Maybe = {
 	* );
 	* ```
 	*/
-	tapNone: (f) => (data) => {
-		if (isNone(data)) f();
-		return data;
+	tapNone: (sideEffect) => (maybe) => {
+		if (isNone(maybe)) sideEffect();
+		return maybe;
 	},
 	/**
 	* 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)
@@ -1075,18 +1120,20 @@ const Maybe = {
 	* 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.
 	*
@@ -1095,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.
@@ -1197,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);
@@ -1213,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;
@@ -1246,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) => {
@@ -1273,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();
@@ -1286,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;
@@ -1329,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);
 		}
 	};
@@ -1346,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;
@@ -1395,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);
 		}
 	};
@@ -1415,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);
@@ -1440,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({
@@ -1462,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({
@@ -1495,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);
 		}
 	};
@@ -1513,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;
@@ -1533,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({
@@ -1547,7 +1596,7 @@ const makeBuffered = (op, size, retryOptions, timeoutOptions) => {
 		} else {
 			buffer.shift().resolve(_evictedNil);
 			buffer.push({
-				input,
+				input: args,
 				resolve
 			});
 			emit({
@@ -1578,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);
 		}
 	};
@@ -1600,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;
@@ -1649,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();
@@ -1702,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);
 		}
 	};
@@ -1721,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;
@@ -1741,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();
 		}));
 	};
@@ -1793,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);
 		}
 	};
@@ -1812,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);
@@ -1837,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({
@@ -1877,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);
 		}
 	};
@@ -1892,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);
@@ -1910,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);
@@ -1961,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);
 		}
 	};
@@ -1977,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;
@@ -2016,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);
 		}
 	};
@@ -2055,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 = {
@@ -2167,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);
@@ -2478,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,
@@ -2550,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.
@@ -2588,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
@@ -2839,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.
@@ -3053,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: {
 		/**
@@ -3124,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");
@@ -3136,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);
@@ -3149,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(
@@ -3177,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.
 	*
@@ -3186,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}`
@@ -3214,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(
@@ -3232,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
@@ -3257,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(
@@ -3270,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(
@@ -3287,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.
@@ -3315,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: {
 		/**
@@ -3328,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.
@@ -3339,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,
@@ -3354,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
@@ -3362,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
 });
@@ -3393,7 +3487,7 @@ const Resource = {
 		* );
 		* ```
 		*/
-		Task: makeTask
+		Task: makeTask$1
 	},
 	/**
 	* Acquires the resource, runs `f` with it, then releases it.
@@ -3456,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: {
 		/**
@@ -3487,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);
@@ -3499,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");
@@ -3517,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));
 		}
@@ -3531,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> =>
@@ -3560,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(
@@ -3590,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
@@ -3603,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(
@@ -3617,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(
@@ -3634,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: {
 		/**
@@ -3650,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.
@@ -3682,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
@@ -3701,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.
@@ -3713,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])`.
 		*
@@ -3723,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.
@@ -3736,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.
 	*
@@ -3745,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.
@@ -3760,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.
 	*
@@ -3772,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;
 	},
@@ -3802,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
@@ -3812,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.
@@ -3828,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
@@ -3941,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];
@@ -4055,10 +4174,10 @@ const State = {
 };
 //#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.
@@ -4100,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.
@@ -4111,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).
@@ -4122,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.
 		*
@@ -4145,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
@@ -4167,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(
@@ -4186,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.
@@ -4213,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.
 	*
@@ -4222,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.
 	*
@@ -4234,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.
 	*
@@ -4249,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.
@@ -4288,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: {
 		/**
@@ -4326,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.
@@ -4337,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.
 		*
@@ -4346,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: { 
 	/**
@@ -4358,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`.
@@ -4372,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
@@ -4414,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(
@@ -4438,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.
@@ -4469,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.
 	*
@@ -4481,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.
@@ -4644,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);
 }
@@ -4687,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);
@@ -4699,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");
@@ -4717,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));
 		}
@@ -4744,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.
@@ -4781,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(
@@ -4855,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(
@@ -4870,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
@@ -4882,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(
@@ -4895,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(
@@ -4912,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
@@ -4934,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.
@@ -4960,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(
@@ -4989,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([
@@ -4999,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);
 	},
@@ -5032,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: {
 		/**
@@ -5081,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.
@@ -5093,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.
@@ -5104,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]).
@@ -5115,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: {
 		/**
@@ -5127,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).
@@ -5137,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.
@@ -5152,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(
@@ -5190,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
@@ -5222,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(
@@ -5242,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([
@@ -5251,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(
@@ -5266,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(
@@ -5278,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.
@@ -5321,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
@@ -5358,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(
@@ -5370,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
@@ -5386,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.
@@ -5415,14 +5720,17 @@ 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])();
@@ -5455,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(
@@ -5519,6 +5829,8 @@ sync: syncTask },
 	* 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(
@@ -5559,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"
 	* ```
@@ -5591,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])();
@@ -5602,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
@@ -5720,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
 	})))),
@@ -5809,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: {
 		/**
@@ -5890,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
@@ -5901,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
@@ -5912,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)
@@ -5919,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(
@@ -5949,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
@@ -5967,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
@@ -5984,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(
@@ -6003,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(
@@ -6023,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
@@ -6040,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"
@@ -6053,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.
@@ -6063,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.
@@ -6080,10 +6422,10 @@ 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