@nlozgachev/pipelined 0.65.0 → 0.67.0

package/dist/{index-DCK_VPog.d.cts → index-NYjtX7XS.d.cts}

@@ -1,5 +1,5 @@
-import { n as Duration, t as RetryPolicy } from "./index-Bs8En5LJ.cjs";
-import { _ as WithSecond, a as Thenable, b as WithValue, c as WithCooldown, d as WithErrors, f as WithFirst, g as WithN, h as WithMinInterval, i as RetryOptions, l as WithDuration, m as WithLog, o as TimeoutOptions, p as WithKind, r as NonEmptyArr, s as WithConcurrency, u as WithError, v as WithSize, x as Deferred, y as WithTimeout } from "./InternalTypes-B1Lh9uw_.cjs";
+import { n as Duration, t as RetryPolicy } from "./index-CTe9CCHY.cjs";
+import { _ as WithSecond, a as Thenable, b as WithValue, c as WithCooldown, d as WithErrors, f as WithFirst, g as WithN, h as WithMinInterval, i as RetryOptions, l as WithDuration, m as WithLog, o as TimeoutOptions, p as WithKind, r as NonEmptyArr, s as WithConcurrency, u as WithError, v as WithSize, x as Deferred, y as WithTimeout } from "./InternalTypes-DxSlzrpu.cjs";
 //#region src/Core/Combinable.d.ts
 /**
  * A type that can combine two values of type `A` into one, with a neutral starting value.
@@ -218,6 +218,145 @@ declare const Equality: {
   tuple: <T extends readonly unknown[]>(...equalities: { [K in keyof T]: Equality<T[K]>; }) => Equality<T>;
 };
 //#endregion
+//#region src/Core/EventBus.d.ts
+/**
+ * An event bus pipeline for a typed message schema `S`.
+ *
+ * `EventBus` provides typed event emission, sequence matching, state reduction,
+ * and structural event bus forwarding.
+ *
+ * @example
+ * ```ts
+ * type AppMessages = {
+ *   userLoggedIn: { userId: string };
+ *   checkoutStarted: { amount: number };
+ * };
+ *
+ * const appBus = EventBus.make<AppMessages>();
+ *
+ * const subscription = EventBus.listen(
+ *   appBus,
+ *   ["userLoggedIn", "checkoutStarted"],
+ *   { ordered: true }
+ * ).reduce(
+ *   (msg, state) => {
+ *     if (msg.kind === "checkoutStarted") {
+ *       return { count: state.count + 1 };
+ *     }
+ *     return state;
+ *   },
+ *   { count: 0 }
+ * );
+ *
+ * EventBus.emit(appBus, {
+ *   kind: "userLoggedIn",
+ *   value: { userId: "user-1" },
+ * });
+ * ```
+ */
+type EventBus<S extends Record<string, unknown>> = {
+  readonly options?: EventBus.Options;
+  /** @internal */
+  readonly _listeners: Set<(msg: EventBus.Message<S>) => void>;
+  /**
+   * @internal
+   * Lazy array snapshot of `_listeners`. Avoids allocating new array objects on every `emit` call
+   * (2.98x emission speedup, 0 heap allocations). Rebuilt whenever `_listeners` is mutated,
+   * guaranteeing reentrancy safety and preventing listeners subscribed mid-emission from executing early.
+   */
+  _listenerArray: Array<(msg: EventBus.Message<S>) => void> | null;
+  /** @internal */
+  readonly _queue: Array<EventBus.Message<S>>;
+  /** @internal */
+  _isEmitting: boolean;
+};
+declare const EventBus: {
+  /**
+   * Constructs a new `EventBus` instance.
+   *
+   * @example
+   * ```ts
+   * const bus = EventBus.make<AppMessages>({ name: "app" });
+   * ```
+   */
+  make: <S extends Record<string, unknown>>(options?: EventBus.Options) => EventBus<S>;
+  /**
+   * Emits a message payload to one or more target event buses.
+   *
+   * Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
+   *
+   * @example
+   * ```ts
+   * EventBus.emit(busA, {
+   *   kind: "userLoggedIn",
+   *   value: { userId: "user-1" },
+   * });
+   *
+   * EventBus.emit([busA, busB], {
+   *   kind: "userLoggedIn",
+   *   value: { userId: "user-1" },
+   * });
+   * ```
+   */
+  emit: <S extends Record<string, unknown>, K extends keyof S & string>(target: EventBus<S> | ReadonlyArray<EventBus<S>>, message: WithKind<K> & WithValue<S[K]>) => void;
+  /**
+   * Forwards messages from one event bus to another (or multiple).
+   *
+   * @example
+   * ```ts
+   * const stop = EventBus.forward({
+   *   from: authBus,
+   *   to: analyticsBus,
+   *   only: ["userLoggedIn"],
+   * });
+   * ```
+   */
+  forward: <S extends Record<string, unknown>>(options: EventBus.ForwardOptions<S>) => () => void;
+  /**
+   * Initiates listener registration on an event bus for specific event kind(s) or sequence.
+   *
+   * @example
+   * ```ts
+   * const sub = EventBus.listen(
+   *   appBus,
+   *   ["userLoggedIn", "checkoutStarted"],
+   *   { ordered: true }
+   * ).reduce(
+   *   (msg, state) => ({ count: state.count + 1 }),
+   *   { count: 0 }
+   * );
+   * ```
+   */
+  listen: <S extends Record<string, unknown>, K extends keyof S & string>(bus: EventBus<S>, events: K | ReadonlyArray<K>, options?: EventBus.SequenceOptions<S>) => EventBus.ListenerBuilder<S>;
+};
+declare namespace EventBus {
+  type Message<S extends Record<string, unknown>> = { [K in keyof S & string]: WithKind<K> & WithValue<S[K]>; }[keyof S & string];
+  type Options = {
+    readonly name?: string;
+    readonly onError?: (error: unknown) => void;
+  };
+  type SequenceOptions<S extends Record<string, unknown>> = {
+    readonly ordered?: boolean;
+    readonly strict?: boolean;
+    readonly once?: boolean;
+    readonly reset?: (keyof S & string) | ReadonlyArray<keyof S & string>;
+    readonly optional?: (keyof S & string) | ReadonlyArray<keyof S & string>;
+  };
+  type Subscription<State> = {
+    readonly unsubscribe: () => void;
+    readonly getState: () => State;
+  };
+  type ForwardOptions<S extends Record<string, unknown>> = {
+    readonly from: EventBus<S>;
+    readonly to: EventBus<S> | ReadonlyArray<EventBus<S>>;
+    readonly only?: ReadonlyArray<keyof S & string>;
+  };
+  type ListenerBuilder<S extends Record<string, unknown>> = {
+    readonly reduce: <State>(reducer: (msg: Message<S>, state: State) => State, initialState: State) => Subscription<State>;
+    readonly tap: (effect: (msg: Message<S>) => void) => () => void;
+  };
+}
+//#endregion
 //#region src/Core/Lazy.d.ts
 /**
  * A synchronous memoized computation. The factory function runs exactly once —
@@ -436,6 +575,16 @@ declare const Lens: {
  */
 type Logged<L, A> = WithValue<A> & WithLog<L>;
 declare 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: <W = never, A = unknown>(value: A, log?: readonly W[]) => Logged<W, A>;
   from: {
     /**
      * Wraps a pure value into a `Logged` with an empty log.
@@ -500,11 +649,11 @@ declare 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: <W, A>(arg: Logged<W, A>) => <B>(data: Logged<W, (a: A) => B>) => Logged<W, B>;
+  apply: <W, A>(arg: Logged<W, A>) => <B>(data: Logged<W, (a: A) => B>) => Logged<W, B>;
   /**
    * Runs a side effect on the value without changing the `Logged`.
    * Useful for debugging or inspecting intermediate values.
@@ -612,6 +761,8 @@ declare const Maybe: {
     /**
      * Type guard that checks if a Maybe is Some.
      *
+     * @see {@link Maybe.is.none}
+     *
      * @example
      * ```ts
      * const value = Maybe.make.some(42);
@@ -624,6 +775,8 @@ declare const Maybe: {
     /**
      * Type guard that checks if a Maybe is None.
      *
+     * @see {@link Maybe.is.some}
+     *
      * @example
      * ```ts
      * const value = Maybe.make.none();
@@ -673,6 +826,17 @@ declare const Maybe: {
      * ```
      */
     Result: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Result<E, A>;
+    /**
+     * 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: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Validation<E, A>;
   };
   from: {
     /**
@@ -712,20 +876,36 @@ declare const Maybe: {
      */
     Result: <E, A>(data: Result<E, A>) => Maybe<A>;
   };
+  /**
+   * Wraps a synchronous operation that may throw, returning a `Maybe<A>`.
+   * Returns `Some(value)` if successful, or `None` if an exception is thrown.
+   *
+   * @example
+   * ```ts
+   * const safeParse = (s: string) => Maybe.tryCatch(() => JSON.parse(s));
+   * safeParse('{"a": 1}'); // Some({ a: 1 })
+   * safeParse('invalid');   // None
+   * ```
+   */
+  tryCatch: <A>(f: () => A) => Maybe<A>;
   /**
    * 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: <A, B>(f: (a: A) => B) => (data: Maybe<A>) => Maybe<B>;
+  map: <A, B>(transform: (value: A) => B) => (maybe: Maybe<A>) => Maybe<B>;
   /**
-   * 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> => {
@@ -737,10 +917,12 @@ declare const Maybe: {
    * pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None
    * ```
    */
-  chain: <A, B>(f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<B>;
+  chain: <A, B>(transform: (value: A) => Maybe<B>) => (maybe: Maybe<A>) => Maybe<B>;
   /**
    * 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(
@@ -752,10 +934,12 @@ declare const Maybe: {
    * ); // "Value: 5"
    * ```
    */
-  fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Maybe<A>) => B;
+  fold: <A, B>(onNone: () => B, onSome: (value: A) => B) => (maybe: Maybe<A>) => B;
   /**
    * Pattern matches on a Maybe, returning the result of the matching case.
    *
+   * @see {@link Maybe.fold} for positional arguments (onNone, onSome).
+   *
    * @example
    * ```ts
    * pipe(
@@ -769,13 +953,16 @@ declare const Maybe: {
    */
   match: <A, B>(cases: {
     none: () => B;
-    some: (a: A) => B;
-  }) => (data: Maybe<A>) => B;
+    some: (value: A) => B;
+  }) => (maybe: Maybe<A>) => B;
   /**
    * 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
@@ -783,11 +970,13 @@ declare const Maybe: {
    * pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
    * ```
    */
-  getOrElse: <B>(defaultValue: () => B) => <A>(data: Maybe<A>) => A | B;
+  getOrElse: <B>(defaultValue: () => B) => <A>(maybe: Maybe<A>) => A | B;
   /**
    * 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(
@@ -797,29 +986,51 @@ declare const Maybe: {
    * );
    * ```
    */
-  tap: <A>(f: (a: A) => void) => (data: Maybe<A>) => Maybe<A>;
+  tap: <A>(sideEffect: (value: A) => void) => (maybe: Maybe<A>) => Maybe<A>;
+  /**
+   * Executes a side effect when the Maybe is None, without changing the Maybe.
+   *
+   * @see {@link Maybe.tap} for running side effects on Some.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.none(),
+   *   Maybe.tapNone(() => console.log("Value missing")),
+   * );
+   * ```
+   */
+  tapNone: (sideEffect: () => void) => <A>(maybe: Maybe<A>) => Maybe<A>;
   /**
-   * Filters a Maybe based on a predicate.
+   * Filters a Maybe based on a predicate or type guard.
    * Returns None if the predicate returns false or if the Maybe is already None.
    *
+   * @see {@link Maybe.map}
+   *
    * @example
    * ```ts
    * pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
    * pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
+   * pipe(Maybe.make.some("hi"), Maybe.filter((x): x is string => typeof x === "string")); // Some("hi")
    * ```
    */
-  filter: <A>(predicate: (a: A) => boolean) => (data: Maybe<A>) => Maybe<A>;
+  filter: {
+    <A, B extends A>(refinement: (value: A) => value is B): (maybe: Maybe<A>) => Maybe<B>;
+    <A>(predicate: (value: A) => boolean): (maybe: Maybe<A>) => Maybe<A>;
+  };
   /**
    * 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: <B>(fallback: () => Maybe<B>) => <A>(data: Maybe<A>) => Maybe<A | B>;
+  recover: <B>(fallback: () => Maybe<B>) => <A>(maybe: Maybe<A>) => Maybe<A | B>;
   /**
    * Applies a function wrapped in a Maybe to a value wrapped in a Maybe.
    *
@@ -828,12 +1039,12 @@ declare 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: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
+  apply: <A>(arg: Maybe<A>) => <B>(data: Maybe<(a: A) => B>) => Maybe<B>;
   /**
    * Converts a Maybe value into an object containing a single property.
    * Initiates the pipeline accumulator record.
@@ -884,6 +1095,7 @@ declare const Maybe: {
 };
 //#endregion
 //#region src/Core/Op.d.ts
+declare const _opBrand: unique symbol;
 /**
  * A reusable description of async work — decoupled from execution strategy and lifetime.
  *
@@ -902,7 +1114,7 @@ declare const Maybe: {
  *       if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
  *       return r.json() as Promise<User>;
  *     }),
- *   (e) => new ApiError(e),
+ *   { onError: (e) => new ApiError(e) },
  * );
  *
  * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
@@ -915,17 +1127,17 @@ declare const Maybe: {
  * manager.run(userId);
  * ```
  */
-type Op<I, E, A> = {
-  /**
-   * @internal — Used by `Op.interpret`. Do not call directly.
-   * Returns `null` when the operation was aborted (signal fired before factory resolved).
-   */
-  readonly _factory: (input: I, signal: AbortSignal) => Deferred<Result<E, A> | null>;
+type Op<Args extends readonly any[] = any[], E = unknown, A = unknown> = {
+  readonly [_opBrand]: {
+    readonly _args: (...args: Args) => void;
+    readonly _error: () => E;
+    readonly _value: () => A;
+  };
 };
 type MaybeRetry<E, O> = O extends {
   retry: RetryOptions<E>;
 } ? Op.Retrying<E> : never;
-type AllInterpretOptions<I, E> = ({
+type AllInterpretOptions<Args extends readonly any[], E> = ({
   strategy: "once";
   retry?: RetryOptions<E>;
 } & WithTimeout<E>) | ({
@@ -939,7 +1151,7 @@ type AllInterpretOptions<I, E> = ({
   retry?: RetryOptions<E>;
   maxSize?: number;
   overflow?: "drop" | "replace-last";
-  dedupe?: (a: I, b: I) => boolean;
+  dedupe?: (a: Args, b: Args) => boolean;
 } & WithConcurrency & WithTimeout<E>) | ({
   strategy: "buffered";
   retry?: RetryOptions<E>;
@@ -959,53 +1171,53 @@ type AllInterpretOptions<I, E> = ({
 } & WithN & WithTimeout<E>) | ({
   strategy: "keyed";
   perKey?: "exclusive" | "restartable";
-  key: (input: I) => unknown;
+  key: (...args: Args) => unknown;
 } & WithTimeout<E>);
-type KeyType<I, O> = O extends {
-  key: (input: I) => infer K;
+type KeyType<Args extends readonly any[], O> = O extends {
+  key: (...args: Args) => infer K;
 } ? K : unknown;
-type InterpretResult<I, E, A, O> = [O] extends [{
+type InterpretResult<Args extends readonly any[], E, A, O> = [O] extends [{
   strategy: "throttled";
   trailing: true;
-}] ? Op.Manager<I, E, A, Op.ThrottledTrailingState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.ThrottledTrailingState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "throttled";
-}] ? Op.Manager<I, E, A, Op.ThrottledState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.ThrottledState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "debounced";
-}] ? Op.Manager<I, E, A, Op.DebouncedState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.DebouncedState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "concurrent";
   overflow: "queue";
-}] ? Op.Manager<I, E, A, Op.ConcurrentQueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.ConcurrentQueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "concurrent";
-}] ? Op.Manager<I, E, A, Op.ConcurrentDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.ConcurrentDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "keyed";
   perKey: "restartable";
-}] ? Op.KeyedManager<I, KeyType<I, O>, E, Op.KeyedRestartablePerKey<E, A>> : [O] extends [{
+}] ? Op.KeyedManager<Args, KeyType<Args, O>, E, Op.KeyedRestartablePerKey<E, A>> : [O] extends [{
   strategy: "keyed";
-}] ? Op.KeyedManager<I, KeyType<I, O>, E, Op.KeyedExclusivePerKey<E, A>> : [O] extends [{
+}] ? Op.KeyedManager<Args, KeyType<Args, O>, E, Op.KeyedExclusivePerKey<E, A>> : [O] extends [{
   strategy: "once";
-}] ? Op.Manager<I, E, A, Op.OnceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.OnceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "restartable";
-}] ? Op.Manager<I, E, A, Op.RestartableState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.RestartableState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "exclusive";
-}] ? Op.Manager<I, E, A, Op.ExclusiveState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.ExclusiveState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "queue";
   overflow: "replace-last";
-  dedupe: (a: I, b: I) => boolean;
-}] ? Op.Manager<I, E, A, Op.QueueDropAndReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+  dedupe: (a: Args, b: Args) => boolean;
+}] ? Op.Manager<Args, E, A, Op.QueueDropAndReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "queue";
   overflow: "replace-last";
-}] ? Op.Manager<I, E, A, Op.QueueReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.QueueReplaceState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "queue";
   maxSize: number;
-}] ? Op.Manager<I, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "queue";
-  dedupe: (a: I, b: I) => boolean;
-}] ? Op.Manager<I, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+  dedupe: (a: Args, b: Args) => boolean;
+}] ? Op.Manager<Args, E, A, Op.QueueDropState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "queue";
-}] ? Op.Manager<I, E, A, Op.QueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
+}] ? Op.Manager<Args, E, A, Op.QueueState<E, A> | MaybeRetry<E, O>> : [O] extends [{
   strategy: "buffered";
-}] ? Op.Manager<I, E, A, Op.BufferedState<E, A> | MaybeRetry<E, O>> : never;
-declare function interpretFn<I, E, A, O extends AllInterpretOptions<I, E>>(op: Op<I, E, A>, options: O): InterpretResult<I, E, A, O>;
+}] ? Op.Manager<Args, E, A, Op.BufferedState<E, A> | MaybeRetry<E, O>> : never;
+declare function interpretFn<Args extends readonly any[], E, A, O extends AllInterpretOptions<Args, E>>(op: Op<Args, E, A>, options: O): InterpretResult<Args, E, A, O>;
 declare const Op: {
   make: {
     /**
@@ -1115,8 +1327,24 @@ declare const Op: {
      */
     nil: <E, A>(state: Op.State<E, A>) => state is Op.Nil;
   };
-  create: <E, A, I = void>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
-  lift: <I, A>(f: (input: I, signal: AbortSignal) => Promise<A>) => Op<I, unknown, A>;
+  /**
+   * 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: <Fn extends (...args: any[]) => Promise<any>, E = unknown>(factory: (signal: AbortSignal) => Fn, options: {
+    onError: (error: unknown) => E;
+  }) => Op<Parameters<Fn>, E, Awaited<ReturnType<Fn>>>;
+  lift: <Fn extends (...args: any[]) => Promise<any>>(f: (signal: AbortSignal) => Fn) => Op<Parameters<Fn>, unknown, Awaited<ReturnType<Fn>>>;
   match: <E, A, B>(cases: {
     ok: (a: A) => B;
     err: (e: E) => B;
@@ -1135,7 +1363,7 @@ declare const Op: {
   };
   all: <E, A>(invocations: ReadonlyArray<Deferred<Op.Outcome<E, A>>>) => Deferred<ReadonlyArray<Op.Outcome<E, A>>>;
   race: <E, A>(invocations: ReadonlyArray<Deferred<Op.Outcome<E, A>>>) => Deferred<Op.Outcome<E, A>>;
-  wire: <I, E, A, S extends Op.State<E, A>>(source: Op.Manager<I, E, A, S>, f: (a: A) => void) => () => void;
+  wire: <Args extends readonly any[], E, A, S extends Op.State<E, A>>(source: Op.Manager<Args, E, A, S>, f: (a: A) => void) => () => void;
   interpret: typeof interpretFn;
 };
 declare namespace Op {
@@ -1169,25 +1397,25 @@ declare namespace Op {
     readonly lastError: E;
     readonly nextRetryIn?: number;
   };
-  type Manager<I, E, A, S extends State<E, A>> = {
+  type Manager<Args extends readonly any[], E, A, S extends State<E, A>> = {
     readonly state: S;
-    run: (input: I) => Deferred<Exclude<S, Idle | Pending | Queued | Retrying<E>>>;
+    run: (...args: Args) => Deferred<Exclude<S, Idle | Pending | Queued | Retrying<E>>>;
     abort: () => void;
     subscribe: (cb: (state: S) => void) => () => void;
     reset: () => void;
-    poll: (input: I, options: {
+    poll: (options: {
       interval: Duration;
-    }) => () => void;
+    }) => (...args: Args) => () => void;
   };
-  type KeyedManager<I, K, E, PerKeyS> = {
+  type KeyedManager<Args extends readonly any[], K, E, PerKeyS> = {
     readonly state: ReadonlyMap<K, PerKeyS>;
-    run: (input: I) => Deferred<Exclude<PerKeyS, Pending | Retrying<E>>>;
+    run: (...args: Args) => Deferred<Exclude<PerKeyS, Pending | Retrying<E>>>;
     abort: (key?: K) => void;
     subscribe: (cb: (state: ReadonlyMap<K, PerKeyS>) => void) => () => void;
     reset: () => void;
-    poll: (input: I, options: {
+    poll: (options: {
       interval: Duration;
-    }) => () => void;
+    }) => (...args: Args) => () => void;
   };
   type OnceState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
   type RetryableOnceState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
@@ -1491,7 +1719,7 @@ declare const Ordering: {
  * import { Pair } from "@nlozgachev/pipelined/core";
  * import { pipe } from "@nlozgachev/pipelined/composition";
  *
- * const entry = Pair.from.pair("alice", 42);
+ * const entry = Pair.make("alice", 42);
  *
  * pipe(
  *   entry,
@@ -1503,16 +1731,16 @@ declare const Ordering: {
  */
 type Pair<A, B> = readonly [A, B];
 declare const Pair: {
+  /**
+   * Creates a Pair from two values.
+   *
+   * @example
+   * ```ts
+   * Pair.make("Paris", 2_161_000); // ["Paris", 2161000]
+   * ```
+   */
+  make: <A, B>(first: A, second: B) => Pair<A, B>;
   from: {
-    /**
-     * Creates a Pair from two values.
-     *
-     * @example
-     * ```ts
-     * Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
-     * ```
-     */
-    pair: <A, B>(first: A, second: B) => Pair<A, B>;
     /**
      * Creates a Pair from a two-element array.
      *
@@ -1521,51 +1749,60 @@ declare const Pair: {
      * Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
      * ```
      */
-    array: <A, B>(arr: readonly [A, B]) => Pair<A, B>;
+    array: <A, B>(items: readonly [A, B]) => Pair<A, B>;
   };
   /**
    * 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: <A, B>(p: Pair<A, B>) => A;
+  first: <A, B>(pair: Pair<A, B>) => A;
   /**
    * 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: <A, B>(p: Pair<A, B>) => B;
+  second: <A, B>(pair: Pair<A, B>) => B;
   /**
    * 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: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
+  mapFirst: <A, C>(transform: (first: A) => C) => <B>(pair: Pair<A, B>) => Pair<C, B>;
   /**
    * 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: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
+  mapSecond: <B, D>(transform: (second: B) => D) => <A>(pair: Pair<A, B>) => Pair<A, D>;
   /**
    * 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,
@@ -1573,37 +1810,37 @@ declare const Pair: {
    * ); // ["ALICE", 84]
    * ```
    */
-  mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (p: Pair<A, B>) => Pair<C, D>;
+  mapBoth: <A, C, B, D>(onFirst: (first: A) => C, onSecond: (second: B) => D) => (pair: Pair<A, B>) => Pair<C, D>;
   /**
    * 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: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
+  fold: <A, B, C>(reducer: (first: A, second: B) => C) => (pair: Pair<A, B>) => C;
   /**
    * 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: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+  swap: <A, B>(pair: Pair<A, B>) => Pair<B, A>;
   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: <A, B>(p: Pair<A, B>) => readonly (A | B)[];
+    array: <A, B>(pair: Pair<A, B>) => readonly (A | B)[];
   };
   /**
    * Runs a side effect with both values without changing the pair.
@@ -1612,13 +1849,13 @@ declare const Pair: {
    * @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: <A, B>(f: (a: A, b: B) => void) => (p: Pair<A, B>) => Pair<A, B>;
+  tap: <A, B>(sideEffect: (first: A, second: B) => void) => (pair: Pair<A, B>) => Pair<A, B>;
 };
 //#endregion
 //#region src/Core/Predicate.d.ts
@@ -1905,12 +2142,12 @@ declare 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: <R, A>(arg: Reader<R, A>) => <B>(data: Reader<R, (a: A) => B>) => Reader<R, B>;
+  apply: <R, A>(arg: Reader<R, A>) => <B>(data: Reader<R, (a: A) => B>) => Reader<R, B>;
   /**
    * Executes a side effect on the produced value without changing the Reader.
    * Useful for logging or debugging inside a pipeline.
@@ -2199,7 +2436,7 @@ declare const RemoteData: {
      * }
      * ```
      */
-    notAsked: <E, A>(data: RemoteData<E, A>) => data is NotAsked;
+    notAsked: <E, A>(remoteData: RemoteData<E, A>) => remoteData is NotAsked;
     /**
      * Type guard that checks if a RemoteData is Loading.
      *
@@ -2211,10 +2448,12 @@ declare const RemoteData: {
      * }
      * ```
      */
-    loading: <E, A>(data: RemoteData<E, A>) => data is Loading;
+    loading: <E, A>(remoteData: RemoteData<E, A>) => remoteData is Loading;
     /**
      * 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");
@@ -2223,10 +2462,12 @@ declare const RemoteData: {
      * }
      * ```
      */
-    failure: <E, A>(data: RemoteData<E, A>) => data is Failure<E>;
+    failure: <E, A>(remoteData: RemoteData<E, A>) => remoteData is Failure<E>;
     /**
      * 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);
@@ -2235,31 +2476,38 @@ declare const RemoteData: {
      * }
      * ```
      */
-    success: <E, A>(data: RemoteData<E, A>) => data is Success<A>;
+    success: <E, A>(remoteData: RemoteData<E, A>) => remoteData is Success<A>;
   };
   /**
    * 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: <A, B>(f: (a: A) => B) => <E>(data: RemoteData<E, A>) => RemoteData<E, B>;
+  map: <A, B>(transform: (value: A) => B) => <E>(remoteData: RemoteData<E, A>) => RemoteData<E, B>;
   /**
    * 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: <E, F>(f: (e: E) => F) => <A>(data: RemoteData<E, A>) => RemoteData<F, A>;
+  mapError: <E, F>(transform: (error: E) => F) => <A>(remoteData: RemoteData<E, A>) => RemoteData<F, A>;
   /**
-   * 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(
@@ -2268,7 +2516,7 @@ declare const RemoteData: {
    * );
    * ```
    */
-  chain: <E2, A, B>(f: (a: A) => RemoteData<E2, B>) => <E1 = never>(data: RemoteData<E1, A>) => RemoteData<E1 | E2, B>;
+  chain: <E2, A, B>(transform: (value: A) => RemoteData<E2, B>) => <E1 = never>(remoteData: RemoteData<E1, A>) => RemoteData<E1 | E2, B>;
   /**
    * Applies a function wrapped in a RemoteData to a value wrapped in a RemoteData.
    *
@@ -2277,21 +2525,23 @@ declare 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: <E, A>(arg: RemoteData<E, A>) => <B>(data: RemoteData<E, (a: A) => B>) => RemoteData<E, B>;
+  apply: <E2, A>(arg: RemoteData<E2, A>) => <E1, B>(remoteData: RemoteData<E1, (value: A) => B>) => RemoteData<E1 | E2, B>;
   /**
    * 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}`
@@ -2299,10 +2549,12 @@ declare const RemoteData: {
    * );
    * ```
    */
-  fold: <E, A, B>(onFailure: (e: E) => B, onNotAsked: () => B, onLoading: () => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
+  fold: <E, A, B>(onFailure: (error: E) => B, onNotAsked: () => B, onLoading: () => B, onSuccess: (value: A) => B) => (remoteData: RemoteData<E, A>) => B;
   /**
    * Pattern matches on a RemoteData, returning the result of the matching case.
    *
+   * @see {@link RemoteData.fold} for positional argument pattern matching.
+   *
    * @example
    * ```ts
    * pipe(
@@ -2310,7 +2562,7 @@ declare const RemoteData: {
    *   RemoteData.match({
    *     notAsked: () => "Click to load",
    *     loading: () => "Loading...",
-   *     failure: e => `Error: ${e}`,
+   *     failure: error => `Error: ${error}`,
    *     success: user => `Hello, ${user.name}!`
    *   })
    * );
@@ -2319,13 +2571,15 @@ declare const RemoteData: {
   match: <E, A, B>(cases: {
     notAsked: () => B;
     loading: () => B;
-    failure: (e: E) => B;
-    success: (a: A) => B;
-  }) => (data: RemoteData<E, A>) => B;
+    failure: (error: E) => B;
+    success: (value: A) => B;
+  }) => (remoteData: RemoteData<E, A>) => B;
   /**
    * 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
@@ -2333,10 +2587,12 @@ declare const RemoteData: {
    * pipe(RemoteData.make.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
    * ```
    */
-  getOrElse: <B>(defaultValue: () => B) => <E, A>(data: RemoteData<E, A>) => A | B;
+  getOrElse: <B>(fallback: () => B) => <E, A>(remoteData: RemoteData<E, A>) => A | B;
   /**
    * 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(
@@ -2346,11 +2602,13 @@ declare const RemoteData: {
    * );
    * ```
    */
-  tap: <E, A>(f: (a: A) => void) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+  tap: <E, A>(sideEffect: (value: A) => void) => (remoteData: RemoteData<E, A>) => RemoteData<E, A>;
   /**
    * 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(
@@ -2360,18 +2618,18 @@ declare const RemoteData: {
    * );
    * ```
    */
-  tapError: <E, A>(f: (e: E) => void) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+  tapError: <E, A>(sideEffect: (error: E) => void) => (remoteData: RemoteData<E, A>) => RemoteData<E, A>;
   /**
    * 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: <E, B>(fallback: (e: E) => RemoteData<E, B>) => <A>(data: RemoteData<E, A>) => RemoteData<E, A | B>;
+  recover: <E1, E2, B>(fallback: (error: E1) => RemoteData<E2, B>) => <A>(remoteData: RemoteData<E1, A>) => RemoteData<E2, A | B>;
   to: {
     /**
      * Converts a RemoteData to a Maybe.
      * Success becomes Some, all other states become None.
      */
-    Maybe: <E, A>(data: RemoteData<E, A>) => Maybe<A>;
+    Maybe: <E, A>(remoteData: RemoteData<E, A>) => Maybe<A>;
     /**
      * Converts a RemoteData to a Result.
      * Success becomes Ok, Failure becomes Err.
@@ -2385,7 +2643,7 @@ declare const RemoteData: {
      * ); // Ok(42)
      * ```
      */
-    Result: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
+    Result: <E>(onNotReady: () => E) => <A>(remoteData: RemoteData<E, A>) => Result<E, A>;
   };
   from: {
     /**
@@ -2398,7 +2656,7 @@ declare const RemoteData: {
      * setState(RemoteData.from.Result(result)); // Success(user) or Failure(msg)
      * ```
      */
-    Result: <E, A>(data: Result<E, A>) => RemoteData<E, A>;
+    Result: <E, A>(result: Result<E, A>) => RemoteData<E, A>;
     /**
      * Converts a Maybe to a RemoteData.
      * Some becomes Success, None becomes Failure using the onNone error producer.
@@ -2409,7 +2667,7 @@ declare const RemoteData: {
      * pipe(Maybe.make.none(), RemoteData.from.Maybe(() => "not found"));     // Failure("not found")
      * ```
      */
-    Maybe: <E>(onNone: () => E) => <A>(data: Maybe<A>) => RemoteData<E, A>;
+    Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => RemoteData<E, A>;
   };
   /**
    * Filters a `Success` value. When the predicate passes, the value is kept. When it fails,
@@ -2424,7 +2682,7 @@ declare const RemoteData: {
    * RemoteData.filter(n => n > 0, () => "error")(RemoteData.make.loading()); // Loading
    * ```
    */
-  filter: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+  filter: <E, A>(predicate: (value: A) => boolean, onFalse: (value: A) => E) => (remoteData: RemoteData<E, A>) => RemoteData<E, A>;
 };
 //#endregion
 //#region src/Core/Resource.d.ts
@@ -2564,12 +2822,14 @@ declare const Result: {
      * Result.make.err("Error message"); // Err("Error message")
      * ```
      */
-    err: <E>(e: E) => Err$1<E>;
+    err: <E>(error: E) => Err$1<E>;
   };
   is: {
     /**
      * 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);
@@ -2578,10 +2838,12 @@ declare const Result: {
      * }
      * ```
      */
-    ok: <E, A>(data: Result<E, A>) => data is Ok$1<A>;
+    ok: <E, A>(result: Result<E, A>) => result is Ok$1<A>;
     /**
      * 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");
@@ -2590,7 +2852,7 @@ declare const Result: {
      * }
      * ```
      */
-    err: <E, A>(data: Result<E, A>) => data is Err$1<E>;
+    err: <E, A>(result: Result<E, A>) => result is Err$1<E>;
   };
   /**
    * Creates a Result from a synchronous thunk that may throw.
@@ -2600,36 +2862,43 @@ declare const Result: {
    * ```ts
    * const result = Result.tryCatch(
    *   () => JSON.parse(rawString),
-   *   { onError: (e) => `Parse error: ${e}` }
+   *   { onError: (error) => `Parse error: ${error}` }
    * );
    * ```
    */
-  tryCatch: <E, A>(f: () => A, options: {
-    onError: (e: unknown) => E;
+  tryCatch: <E, A>(fn: () => A, options: {
+    onError: (error: unknown) => E;
   }) => Result<E, A>;
   /**
    * 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: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
+  map: <E, A, B>(transform: (value: A) => B) => (result: Result<E, A>) => Result<E, B>;
   /**
    * 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: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
+  mapError: <E, F, A>(transform: (error: E) => F) => (result: Result<E, A>) => Result<F, A>;
   /**
-   * 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> =>
@@ -2639,25 +2908,29 @@ declare const Result: {
    * pipe(Result.make.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
    * ```
    */
-  chain: <E2, A, B>(f: (a: A) => Result<E2, B>) => <E1 = never>(data: Result<E1, A>) => Result<E1 | E2, B>;
+  chain: <E2, A, B>(transform: (value: A) => Result<E2, B>) => <E1 = never>(result: Result<E1, A>) => Result<E1 | E2, B>;
   /**
    * 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: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Result<E, A>) => B;
+  fold: <E, A, B>(onErr: (error: E) => B, onOk: (value: A) => B) => (result: Result<E, A>) => B;
   /**
    * Pattern matches on a Result, returning the result of the matching case.
    *
+   * @see {@link Result.fold} for positional argument pattern matching.
+   *
    * @example
    * ```ts
    * pipe(
@@ -2670,14 +2943,16 @@ declare const Result: {
    * ```
    */
   match: <E, A, B>(cases: {
-    ok: (a: A) => B;
-    err: (e: E) => B;
-  }) => (data: Result<E, A>) => B;
+    ok: (value: A) => B;
+    err: (error: E) => B;
+  }) => (result: Result<E, A>) => B;
   /**
    * 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
@@ -2685,11 +2960,13 @@ declare const Result: {
    * pipe(Result.make.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
    * ```
    */
-  getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Result<E, A>) => A | B;
+  getOrElse: <B>(fallback: () => B) => <E, A>(result: Result<E, A>) => A | B;
   /**
    * 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(
@@ -2699,11 +2976,13 @@ declare const Result: {
    * );
    * ```
    */
-  tap: <E, A>(f: (a: A) => void) => (data: Result<E, A>) => Result<E, A>;
+  tap: <E, A>(sideEffect: (value: A) => void) => (result: Result<E, A>) => Result<E, A>;
   /**
    * 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(
@@ -2713,7 +2992,7 @@ declare const Result: {
    * )
    * ```
    */
-  tapError: <E, A>(f: (e: E) => void) => (data: Result<E, A>) => Result<E, A>;
+  tapError: <E, A>(sideEffect: (error: E) => void) => (result: Result<E, A>) => Result<E, A>;
   from: {
     /**
      * Creates a Result from a predicate applied to a value.
@@ -2726,7 +3005,7 @@ declare const Result: {
      * pipe("", Result.from.Predicate(s => s.length > 0, () => "empty string")); // Err("empty string")
      * ```
      */
-    Predicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
+    Predicate: <E, A>(predicate: (value: A) => boolean, onFalse: (value: A) => E) => (value: A) => Result<E, A>;
     /**
      * Creates a Result from a nullable value.
      * Returns Ok if the value is not null or undefined, error from onNull otherwise.
@@ -2758,16 +3037,20 @@ declare const Result: {
      * Result.from.Validation((errors) => errors.join(", "))(Validation.make.failed("error1")); // Err("error1")
      * ```
      */
-    Validation: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (val: Validation<E1, A>) => Result<E2, A>;
+    Validation: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (validation: Validation<E1, A>) => Result<E2, A>;
   };
   /**
    * 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: <E, B>(fallback: (e: E) => Result<E, B>) => <A>(data: Result<E, A>) => Result<E, A | B>;
+  recover: <E1, E2, B>(fallback: (error: E1) => Result<E2, B>) => <A>(result: Result<E1, A>) => Result<E2, A | B>;
   /**
    * 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
@@ -2777,7 +3060,7 @@ declare const Result: {
    * ); // Ok(0)
    * ```
    */
-  recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => <A>(data: Result<E, A>) => Result<E, A | B>;
+  recoverUnless: <E1, E2, B>(isBlocked: (error: E1) => boolean, fallback: (error: E1) => Result<E2, B>) => <A>(result: Result<E1, A>) => Result<E1 | E2, A | B>;
   to: {
     /**
      * Converts a Result to a Maybe.
@@ -2789,7 +3072,7 @@ declare const Result: {
      * Result.to.Maybe(Result.make.err("oops")); // None
      * ```
      */
-    Maybe: <E, A>(data: Result<E, A>) => Maybe<A>;
+    Maybe: <E, A>(result: Result<E, A>) => Maybe<A>;
     /**
      * Converts a `Result` to a `Validation`. `Ok(a)` becomes `Passed(a)`; `Err(e)` becomes `Failed([e])`.
      *
@@ -2799,7 +3082,7 @@ declare const Result: {
      * Result.to.Validation(Result.make.err("bad")); // Failed(["bad"])
      * ```
      */
-    Validation: <E, A>(data: Result<E, A>) => Validation<E, A>;
+    Validation: <E, A>(result: Result<E, A>) => Validation<E, A>;
   };
   /**
    * Swaps the outer `Result` and inner `Maybe` context.
@@ -2812,7 +3095,7 @@ declare const Result: {
    * Result.transposeMaybe(Result.make.err("error"));           // Some(Err("error"))
    * ```
    */
-  transposeMaybe: <E, A>(data: Result<E, Maybe<A>>) => Maybe<Result<E, A>>;
+  transposeMaybe: <E, A>(result: Result<E, Maybe<A>>) => Maybe<Result<E, A>>;
   /**
    * Applies a function wrapped in a Result to a value wrapped in a Result.
    *
@@ -2821,12 +3104,12 @@ declare 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: <E, A>(arg: Result<E, A>) => <B>(data: Result<E, (a: A) => B>) => Result<E, B>;
+  apply: <E2, A>(arg: Result<E2, A>) => <E1, B>(result: Result<E1, (value: A) => B>) => Result<E1 | E2, B>;
   /**
    * Converts a Result value into an object containing a single property.
    * Initiates the pipeline accumulator record.
@@ -2836,7 +3119,7 @@ declare const Result: {
    * pipe(Result.make.ok(42), Result.bindTo("value")); // Ok({ value: 42 })
    * ```
    */
-  bindTo: <K extends string>(key: K) => <E, A>(data: Result<E, A>) => Result<E, { [P in K]: A; }>;
+  bindTo: <K extends string>(key: K) => <E, A>(result: Result<E, A>) => Result<E, { [P in K]: A; }>;
   /**
    * Evaluates a new Result using the current accumulator and attaches the output to a new key.
    *
@@ -2848,7 +3131,7 @@ declare const Result: {
    * ); // Ok({ a: 1, b: 2 })
    * ```
    */
-  bind: <K extends string, E, A, B>(key: K, f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, A & { [P in K]: B; }>;
+  bind: <K extends string, E2, A, B>(key: K, transform: (value: A) => Result<E2, B>) => <E1 = never>(result: Result<E1, A>) => Result<E1 | E2, A & { [P in K]: B; }>;
   /**
    * Combines a record of Results into a single Result of a record.
    * Evaluates fields in key order and short-circuits on the first failure.
@@ -2863,7 +3146,7 @@ declare const Result: {
    */
   struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Result<E, R[K]>; }) => Result<E, R>;
   /**
-   * 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
@@ -2873,7 +3156,7 @@ declare const Result: {
    * ); // Err("Age 15 is below 18")
    * ```
    */
-  ensure: <A, E2>(predicate: (a: A) => boolean, onFail: (a: A) => E2) => <E1 = never>(data: Result<E1, A>) => Result<E1 | E2, A>;
+  ensure: <A, E2>(predicate: (value: A) => boolean, onFail: (value: A) => E2) => <E1 = never>(result: Result<E1, A>) => Result<E1 | E2, A>;
   /**
    * Transforms both branches of a Result simultaneously.
    * Applies `onErr` to `Err` values and `onOk` to `Ok` values.
@@ -2889,7 +3172,7 @@ declare const Result: {
    * ); // Ok(10)
    * ```
    */
-  bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (data: Result<E1, A>) => Result<E2, B>;
+  bimap: <E1, E2, A, B>(onErr: (error: E1) => E2, onOk: (value: A) => B) => (result: Result<E1, A>) => Result<E2, B>;
 };
 //#endregion
 //#region src/Core/State.d.ts
@@ -3019,14 +3302,14 @@ declare const State$1: {
    * 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: <S, A>(arg: State$1<S, A>) => <B>(fn: State$1<S, (a: A) => B>) => State$1<S, B>;
+  apply: <S, A>(arg: State$1<S, A>) => <B>(fn: State$1<S, (a: A) => B>) => State$1<S, B>;
   /**
    * Runs a side effect on the produced value without changing the State computation.
    *
@@ -3118,145 +3401,6 @@ declare const State$1: {
   focus: <S, A>(lens: Lens<S, A>) => <B>(stateOp: State$1<A, B>) => State$1<S, B>;
 };
 //#endregion
-//#region src/Core/Stream.d.ts
-/**
- * An event stream pipeline for a typed message schema `S`.
- *
- * `Stream` provides typed event emission, sequence matching, state reduction,
- * and structural stream forwarding.
- *
- * @example
- * ```ts
- * type AppMessages = {
- *   userLoggedIn: { userId: string };
- *   checkoutStarted: { amount: number };
- * };
- *
- * const appStream = Stream.make<AppMessages>();
- *
- * const subscription = Stream.listen(
- *   appStream,
- *   ["userLoggedIn", "checkoutStarted"],
- *   { ordered: true }
- * ).reduce(
- *   (msg, state) => {
- *     if (msg.kind === "checkoutStarted") {
- *       return { count: state.count + 1 };
- *     }
- *     return state;
- *   },
- *   { count: 0 }
- * );
- *
- * Stream.emit(appStream, {
- *   kind: "userLoggedIn",
- *   value: { userId: "user-1" },
- * });
- * ```
- */
-type Stream<S extends Record<string, unknown>> = {
-  readonly options?: Stream.Options;
-  /** @internal */
-  readonly _listeners: Set<(msg: Stream.Message<S>) => void>;
-  /**
-   * @internal
-   * Lazy array snapshot of `_listeners`. Avoids allocating new array objects on every `emit` call
-   * (2.98x emission speedup, 0 heap allocations). Rebuilt whenever `_listeners` is mutated,
-   * guaranteeing reentrancy safety and preventing listeners subscribed mid-emission from executing early.
-   */
-  _listenerArray: Array<(msg: Stream.Message<S>) => void> | null;
-  /** @internal */
-  readonly _queue: Array<Stream.Message<S>>;
-  /** @internal */
-  _isEmitting: boolean;
-};
-declare const Stream: {
-  /**
-   * Constructs a new `Stream` instance.
-   *
-   * @example
-   * ```ts
-   * const stream = Stream.make<AppMessages>({ name: "app" });
-   * ```
-   */
-  make: <S extends Record<string, unknown>>(options?: Stream.Options) => Stream<S>;
-  /**
-   * Emits a message payload to one or more target streams.
-   *
-   * Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
-   *
-   * @example
-   * ```ts
-   * Stream.emit(streamA, {
-   *   kind: "userLoggedIn",
-   *   value: { userId: "user-1" },
-   * });
-   *
-   * Stream.emit([streamA, streamB], {
-   *   kind: "userLoggedIn",
-   *   value: { userId: "user-1" },
-   * });
-   * ```
-   */
-  emit: <S extends Record<string, unknown>, K extends keyof S & string>(target: Stream<S> | ReadonlyArray<Stream<S>>, message: WithKind<K> & WithValue<S[K]>) => void;
-  /**
-   * Forwards messages from one stream to another (or multiple).
-   *
-   * @example
-   * ```ts
-   * const stop = Stream.forward({
-   *   from: authStream,
-   *   to: analyticsStream,
-   *   only: ["userLoggedIn"],
-   * });
-   * ```
-   */
-  forward: <S extends Record<string, unknown>>(options: Stream.ForwardOptions<S>) => () => void;
-  /**
-   * Initiates listener registration on a stream for specific event kind(s) or sequence.
-   *
-   * @example
-   * ```ts
-   * const sub = Stream.listen(
-   *   appStream,
-   *   ["userLoggedIn", "checkoutStarted"],
-   *   { ordered: true }
-   * ).reduce(
-   *   (msg, state) => ({ count: state.count + 1 }),
-   *   { count: 0 }
-   * );
-   * ```
-   */
-  listen: <S extends Record<string, unknown>, K extends keyof S & string>(stream: Stream<S>, events: K | ReadonlyArray<K>, options?: Stream.SequenceOptions<S>) => Stream.ListenerBuilder<S>;
-};
-declare namespace Stream {
-  type Message<S extends Record<string, unknown>> = { [K in keyof S & string]: WithKind<K> & WithValue<S[K]>; }[keyof S & string];
-  type Options = {
-    readonly name?: string;
-    readonly onError?: (error: unknown) => void;
-  };
-  type SequenceOptions<S extends Record<string, unknown>> = {
-    readonly ordered?: boolean;
-    readonly strict?: boolean;
-    readonly once?: boolean;
-    readonly reset?: (keyof S & string) | ReadonlyArray<keyof S & string>;
-    readonly optional?: (keyof S & string) | ReadonlyArray<keyof S & string>;
-  };
-  type Subscription<State> = {
-    readonly unsubscribe: () => void;
-    readonly getState: () => State;
-  };
-  type ForwardOptions<S extends Record<string, unknown>> = {
-    readonly from: Stream<S>;
-    readonly to: Stream<S> | ReadonlyArray<Stream<S>>;
-    readonly only?: ReadonlyArray<keyof S & string>;
-  };
-  type ListenerBuilder<S extends Record<string, unknown>> = {
-    readonly reduce: <State>(reducer: (msg: Message<S>, state: State) => State, initialState: State) => Subscription<State>;
-    readonly tap: (effect: (msg: Message<S>) => void) => () => void;
-  };
-}
-//#endregion
 //#region src/Core/Validation.d.ts
 /**
  * Validation represents a value that is either passed with a success value,
@@ -3286,8 +3430,8 @@ declare namespace Stream {
 type Validation<E, A> = Passed<A> | Failed<E>;
 type Passed<A> = WithKind<"Passed"> & WithValue<A>;
 type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
-declare function toResult<E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2): (val: Validation<E1, A>) => Result<E2, A>;
-declare function toResult<E, A>(data: Validation<E, A>): Result<NonEmptyArr<E>, A>;
+declare function toResult<E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2): (validation: Validation<E1, A>) => Result<E2, A>;
+declare function toResult<E, A>(validation: Validation<E, A>): Result<NonEmptyArr<E>, A>;
 declare const Validation: {
   make: {
     /**
@@ -3322,6 +3466,8 @@ declare 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);
@@ -3330,10 +3476,12 @@ declare const Validation: {
      * }
      * ```
      */
-    passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
+    passed: <E, A>(validation: Validation<E, A>) => validation is Passed<A>;
     /**
      * 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");
@@ -3342,7 +3490,7 @@ declare const Validation: {
      * }
      * ```
      */
-    failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
+    failed: <E, A>(validation: Validation<E, A>) => validation is Failed<E>;
   };
   /**
    * Creates a Validation from a synchronous thunk that may throw.
@@ -3352,12 +3500,12 @@ declare const Validation: {
    * ```ts
    * const result = Validation.tryCatch(
    *   () => JSON.parse(rawString),
-   *   { onError: (e) => `Parse error: ${e}` }
+   *   { onError: (error) => `Parse error: ${error}` }
    * );
    * ```
    */
-  tryCatch: <E, A>(f: () => A, options: {
-    onError: (e: unknown) => E;
+  tryCatch: <E, A>(fn: () => A, options: {
+    onError: (error: unknown) => E;
   }) => Validation<E, A>;
   from: {
     /**
@@ -3375,7 +3523,7 @@ declare const Validation: {
      * validateName("");      // Failed(["Name is required"])
      * ```
      */
-    Predicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Validation<E, A>;
+    Predicate: <E, A>(predicate: (value: A) => boolean, onFalse: (value: A) => E) => (value: A) => Validation<E, A>;
     /**
      * Creates a Validation from a nullable value.
      * If the value is null or undefined, returns Failed with the error from onNull.
@@ -3412,63 +3560,71 @@ declare const Validation: {
      * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
      * ```
      */
-    Result: <E, A>(data: Result<E, A>) => Validation<E, A>;
+    Result: <E, A>(result: Result<E, A>) => Validation<E, A>;
   };
   /**
    * 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: <A, B>(f: (a: A) => B) => <E>(data: Validation<E, A>) => Validation<E, B>;
+  map: <A, B>(transform: (value: A) => B) => <E>(validation: Validation<E, A>) => Validation<E, B>;
   /**
    * 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: <E, F, A>(f: (e: E) => F) => (data: Validation<E, A>) => Validation<F, A>;
+  mapError: <E, F, A>(transform: (error: E) => F) => (validation: Validation<E, A>) => Validation<F, A>;
   /**
    * 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: <E, A>(arg: Validation<E, A>) => <B>(data: Validation<E, (a: A) => B>) => Validation<E, B>;
-  /**
-   * 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: <E1, E2, E3>(concat: (e1: NonEmptyArr<E1>, e2: NonEmptyArr<E2>) => NonEmptyArr<E3>) => <A>(arg: Validation<E2, A>) => <B>(data: Validation<E1, (a: A) => B>) => Validation<E3, B>;
+  apply: <E2, A, E3 = never>(arg: Validation<E2, A>, options?: {
+    combineErrors?: (e1: NonEmptyArr<any>, e2: NonEmptyArr<E2>) => NonEmptyArr<E3>;
+  }) => <B, E1 = never>(validation: Validation<E1, (value: A) => B>) => Validation<[E3] extends [never] ? E1 | E2 : E3, B>;
   /**
    * 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(
@@ -3480,10 +3636,12 @@ declare const Validation: {
    * );
    * ```
    */
-  fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
+  fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (value: A) => B) => (validation: Validation<E, A>) => B;
   /**
    * Pattern matches on a Validation, returning the result of the matching case.
    *
+   * @see {@link Validation.fold} for positional argument pattern matching.
+   *
    * @example
    * ```ts
    * pipe(
@@ -3496,13 +3654,15 @@ declare const Validation: {
    * ```
    */
   match: <E, A, B>(cases: {
-    passed: (a: A) => B;
+    passed: (value: A) => B;
     failed: (errors: NonEmptyArr<E>) => B;
-  }) => (data: Validation<E, A>) => B;
+  }) => (validation: Validation<E, A>) => B;
   /**
    * 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
@@ -3510,10 +3670,12 @@ declare const Validation: {
    * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => null)); // null — typed as number | null
    * ```
    */
-  getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Validation<E, A>) => A | B;
+  getOrElse: <B>(fallback: () => B) => <E, A>(validation: Validation<E, A>) => A | B;
   /**
    * 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(
@@ -3523,11 +3685,13 @@ declare const Validation: {
    * );
    * ```
    */
-  tap: <E, A>(f: (a: A) => void) => (data: Validation<E, A>) => Validation<E, A>;
+  tap: <E, A>(sideEffect: (value: A) => void) => (validation: Validation<E, A>) => Validation<E, A>;
   /**
    * 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(
@@ -3537,16 +3701,20 @@ declare const Validation: {
    * );
    * ```
    */
-  tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: Validation<E, A>) => Validation<E, A>;
+  tapError: <E, A>(sideEffect: (errors: NonEmptyArr<E>) => void) => (validation: Validation<E, A>) => Validation<E, A>;
   /**
    * 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: <E, B>(fallback: (errors: NonEmptyArr<E>) => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
+  recover: <E1, E2, B>(fallback: (errors: NonEmptyArr<E1>) => Validation<E2, B>) => <A>(validation: Validation<E1, A>) => Validation<E2, A | B>;
   /**
    * 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
@@ -3556,7 +3724,7 @@ declare const Validation: {
    * ); // Passed(0)
    * ```
    */
-  recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
+  recoverUnless: <E1, E2, B>(isBlocked: (error: E1) => boolean, fallback: (errors: NonEmptyArr<E1>) => Validation<E2, B>) => <A>(validation: Validation<E1, A>) => Validation<E1 | E2, A | B>;
   to: {
     /**
      * Converts a Validation to a Result.
@@ -3582,13 +3750,16 @@ declare const Validation: {
      * Validation.to.Maybe(Validation.make.failed("bad"));  // None
      * ```
      */
-    Maybe: <E, A>(data: Validation<E, A>) => Maybe<A>;
+    Maybe: <E, A>(validation: Validation<E, A>) => Maybe<A>;
   };
   /**
    * 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(
@@ -3608,6 +3779,8 @@ declare 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([
@@ -3618,7 +3791,7 @@ declare const Validation: {
    * // Passed([name, email, age]) or Failed([...all errors])
    * ```
    */
-  productAll: <E, A>(data: NonEmptyArr<Validation<E, A>>) => Validation<E, readonly A[]>;
+  productAll: <E, A>(validations: NonEmptyArr<Validation<E, A>>) => Validation<E, readonly A[]>;
   /**
    * Combines a record of Validations into a single Validation of a record.
    * Accumulates all failed branches' errors.
@@ -3637,7 +3810,87 @@ declare const Validation: {
    * ```
    */
   struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
+  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: <T extends Record<string, any>, E = unknown>(validators: { readonly [K in keyof T]: (val: T[K]) => Validation<E, T[K]>; }) => (input: T) => { readonly [K in keyof T]: Validation<E, T[K]>; };
+    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: <T extends Record<string, any>, E>(keyed: { readonly [K in keyof T]: Validation<E, T[K]>; }) => keyed is { readonly [K in keyof T]: Passed<T[K]>; };
+      /**
+       * 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: <T extends Record<string, any>, E>(keyed: { readonly [K in keyof T]: Validation<E, T[K]>; }) => boolean;
+    };
+    /**
+     * 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: <T extends Record<string, any>, E>(keyed: { readonly [K in keyof T]: Validation<E, T[K]>; }) => Maybe<T>;
+    /**
+     * 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: <T extends Record<string, any>, E>(keyed: { readonly [K in keyof T]: Validation<E, T[K]>; }) => Maybe<Validation.KeyedErrors<T, E>>;
+  };
 };
+declare namespace Validation {
+  type Passed<A> = WithKind<"Passed"> & WithValue<A>;
+  type Failed<E> = WithKind<"Failed"> & WithErrors<E>;
+  type KeyedErrors<T, E = unknown> = { readonly [K in keyof T]?: NonEmptyArr<E>; };
+  type KeyedResult<T, E> = { readonly [K in keyof T]: Validation<E, T[K]>; };
+}
 //#endregion
 //#region src/Core/Task.d.ts
 /**
@@ -3649,7 +3902,7 @@ declare const Validation: {
  *   return type using `Task.Result<E, A>` instead.
  *
  * An optional `AbortSignal` can be passed at the call site. Combinators like
- * `retry`, `pollUntil`, and `timeout` thread it automatically to every inner
+ * `retry`, `poll`, and `timeout` thread it automatically to every inner
  * operation. Existing tasks that ignore the signal continue to work unchanged.
  *
  * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
@@ -3670,7 +3923,7 @@ declare const Validation: {
  *
  * @example
  * ```ts
- * const getTimestamp: Task<number> = Task.resolve(Date.now());
+ * const getTimestamp: Task<number> = Task.make(Date.now());
  *
  * // Nothing runs yet — getTimestamp is just a description
  * const formatted = pipe(
@@ -3689,15 +3942,15 @@ declare const Task: {
    *
    * @example
    * ```ts
-   * const task = Task.resolve(42);
+   * const task = Task.make(42);
    * const value = await task(); // 42
    * ```
    */
-  resolve: <A>(value: A) => Task<A>;
+  make: <A>(value: A) => Task<A>;
   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
@@ -3705,7 +3958,7 @@ declare const Task: {
      * const ts = await t(); // called here, every time
      * ```
      */
-    sync: <A>(f: () => A) => Task<A>;
+    sync: <A>(fn: () => A) => Task<A>;
   };
   /**
    * Wraps a Promise-returning thunk that may throw or reject,
@@ -3719,12 +3972,14 @@ declare const Task: {
    * );
    * ```
    */
-  tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
+  tryCatch: <A>(fn: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
     onError: (error: unknown) => A;
   }) => Task<A>;
   /**
    * Transforms the value inside a Task.
    *
+   * @see {@link Task.chain} to sequence operations that return a Task.
+   *
    * @example
    * ```ts
    * pipe(
@@ -3733,9 +3988,11 @@ declare const Task: {
    * )(); // Deferred<10>
    * ```
    */
-  map: <A, B>(f: (a: A) => B) => (data: Task<A>) => Task<B>;
+  map: <A, B>(transform: (value: A) => B) => (task: Task<A>) => Task<B>;
   /**
-   * 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
@@ -3749,22 +4006,24 @@ declare const Task: {
    * )(); // Deferred<Preferences>
    * ```
    */
-  chain: <A, B>(f: (a: A) => Task<B>) => (data: Task<A>) => Task<B>;
+  chain: <A, B>(transform: (value: A) => Task<B>) => (task: Task<A>) => Task<B>;
   /**
    * 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: <A>(arg: Task<A>) => <B>(data: Task<(a: A) => B>) => Task<B>;
+  apply: <A>(arg: Task<A>) => <B>(task: Task<(value: A) => B>) => Task<B>;
   /**
    * Executes a side effect on the value without changing the Task.
    * Useful for logging or debugging.
@@ -3778,17 +4037,25 @@ declare const Task: {
    * );
    * ```
    */
-  tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
+  tap: <A>(sideEffect: (value: A) => void) => (task: Task<A>) => Task<A>;
   /**
    * Runs multiple Tasks in parallel and collects their results.
+   * An optional `concurrency` option limits the number of tasks executing at any given time.
+   *
+   * @see {@link Task.sequence} to run an array of Tasks concurrently.
+   * @see {@link Task.sequential} to run an array of Tasks one after another in order.
    *
    * @example
    * ```ts
    * Task.all([loadConfig, detectLocale, loadTheme])();
    * // Deferred<[Config, string, Theme]>
+   *
+   * Task.all([loadConfig, detectLocale, loadTheme], { concurrency: 2 })();
    * ```
    */
-  all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
+  all: <T extends readonly Task<unknown>[]>(tasks: T, options?: {
+    concurrency?: number;
+  }) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
   /**
    * Delays the execution of a Task by the specified duration.
    * Useful for debouncing or rate limiting.
@@ -3796,16 +4063,18 @@ declare const Task: {
    * @example
    * ```ts
    * pipe(
-   *   Task.resolve(42),
+   *   Task.make(42),
    *   Task.delay(Duration.seconds(1))
    * )(); // Resolves after 1 second
    * ```
    */
-  delay: (duration: Duration) => <A>(data: Task<A>) => Task<A>;
+  delay: (duration: Duration) => <A>(task: Task<A>) => Task<A>;
   /**
    * 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(
@@ -3819,23 +4088,25 @@ declare const Task: {
     delay?: Duration;
   }) => <A>(task: Task<A>) => Task<readonly A[]>;
   /**
-   * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-   * An optional delay duration can be inserted between runs.
-   * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+   * Polls a Task repeatedly until the result satisfies a predicate, returning that result.
+   * An optional delay duration can be inserted between polling runs.
+   * An optional `attempts` cap stops the loop after N calls — the last value is returned
    * regardless of whether the predicate was satisfied.
    *
+   * @see {@link Task.repeat} to run a Task a fixed number of times.
+   *
    * @example
    * ```ts
    * pipe(
    *   checkStatus,
-   *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
+   *   Task.poll({ until: (s) => s === "ready", delay: Duration.milliseconds(500) })
    * )(); // polls every 500ms until status is "ready"
    * ```
    */
-  repeatUntil: <A>(options: {
-    when: (a: A) => boolean;
+  poll: <A>(options: {
+    until: (value: A) => boolean;
     delay?: Duration;
-    maxAttempts?: number;
+    attempts?: number;
   }) => (task: Task<A>) => Task<A>;
   /**
    * Resolves with the value of the first Task to complete. All Tasks start
@@ -3844,8 +4115,8 @@ declare const Task: {
    *
    * @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"
    * ```
@@ -3855,6 +4126,9 @@ declare const Task: {
    * 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])();
@@ -3866,10 +4140,12 @@ declare const Task: {
    * 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
@@ -3939,22 +4215,22 @@ declare const Task: {
    *
    * @example
    * ```ts
-   * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
+   * pipe(Task.make(42), Task.bindTo("value")); // Task({ value: 42 })
    * ```
    */
-  bindTo: <K extends string>(key: K) => <A>(data: Task<A>) => Task<{ [P in K]: A; }>;
+  bindTo: <K extends string>(key: K) => <A>(task: Task<A>) => Task<{ [P in K]: 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: <K extends string, A, B>(key: K, f: (a: A) => Task<B>) => (data: Task<A>) => Task<A & { [P in K]: B; }>;
+  bind: <K extends string, A, B>(key: K, transform: (value: A) => Task<B>) => (task: Task<A>) => Task<A & { [P in K]: B; }>;
   /**
    * Creates a memoized version of a Task. The task is executed at most once on first call,
    * and its resolved value is cached for all subsequent calls.
@@ -3995,29 +4271,29 @@ declare const Task: {
       none: <A = never>() => Task.Maybe<A>;
     };
     from: {
-      Maybe: <A>(option: Maybe<A>) => Task.Maybe<A>;
+      Maybe: <A>(maybe: Maybe<A>) => Task.Maybe<A>;
       nullable: <A>(value: A | null | undefined) => Task.Maybe<A>;
       Result: <E, A>(result: Result<E, A>) => Task.Maybe<A>;
       Task: <A>(task: Task<A>) => Task.Maybe<A>;
     };
-    tryCatch: <A>(f: (signal?: AbortSignal) => Thenable<A>) => Task.Maybe<A>;
-    map: <A, B>(f: (a: A) => B) => (data: Task.Maybe<A>) => Task.Maybe<B>;
-    chain: <A, B>(f: (a: A) => Task.Maybe<B>) => (data: Task.Maybe<A>) => Task.Maybe<B>;
-    ap: <A>(arg: Task.Maybe<A>) => <B>(data: Task.Maybe<(a: A) => B>) => Task.Maybe<B>;
-    fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Task.Maybe<A>) => Task<B>;
+    tryCatch: <A>(fn: (signal?: AbortSignal) => Thenable<A>) => Task.Maybe<A>;
+    map: <A, B>(transform: (value: A) => B) => (task: Task.Maybe<A>) => Task.Maybe<B>;
+    chain: <A, B>(transform: (value: A) => Task.Maybe<B>) => (task: Task.Maybe<A>) => Task.Maybe<B>;
+    apply: <A>(arg: Task.Maybe<A>) => <B>(task: Task.Maybe<(value: A) => B>) => Task.Maybe<B>;
+    fold: <A, B>(onNone: () => B, onSome: (value: A) => B) => (task: Task.Maybe<A>) => Task<B>;
     match: <A, B>(cases: {
       none: () => B;
-      some: (a: A) => B;
-    }) => (data: Task.Maybe<A>) => Task<B>;
-    getOrElse: <B>(defaultValue: () => B) => <A>(data: Task.Maybe<A>) => Task<A | B>;
-    tap: <A>(f: (a: A) => void) => (data: Task.Maybe<A>) => Task.Maybe<A>;
-    filter: <A>(predicate: (a: A) => boolean) => (data: Task.Maybe<A>) => Task.Maybe<A>;
+      some: (value: A) => B;
+    }) => (task: Task.Maybe<A>) => Task<B>;
+    getOrElse: <B>(fallback: () => B) => <A>(task: Task.Maybe<A>) => Task<A | B>;
+    tap: <A>(sideEffect: (value: A) => void) => (task: Task.Maybe<A>) => Task.Maybe<A>;
+    filter: <A>(predicate: (value: A) => boolean) => (task: Task.Maybe<A>) => Task.Maybe<A>;
     to: {
-      Result: <E>(onNone: () => E) => <A>(data: Task.Maybe<A>) => Task.Result<E, A>;
+      Result: <E>(onNone: () => E) => <A>(task: Task.Maybe<A>) => Task.Result<E, A>;
     };
-    bindTo: <K extends string>(key: K) => <A>(data: Task.Maybe<A>) => Task.Maybe<{ [P in K]: A; }>;
-    bind: <K extends string, A, B>(key: K, f: (a: A) => Task.Maybe<B>) => (data: Task.Maybe<A>) => Task.Maybe<A & { [P in K]: B; }>;
-    recover: <B>(fallback: () => Task.Maybe<B>) => <A>(data: Task.Maybe<A>) => Task.Maybe<A | B>;
+    bindTo: <K extends string>(key: K) => <A>(task: Task.Maybe<A>) => Task.Maybe<{ [P in K]: A; }>;
+    bind: <K extends string, A, B>(key: K, transform: (value: A) => Task.Maybe<B>) => (task: Task.Maybe<A>) => Task.Maybe<A & { [P in K]: B; }>;
+    recover: <B>(fallback: () => Task.Maybe<B>) => <A>(task: Task.Maybe<A>) => Task.Maybe<A | B>;
     struct: <R extends Record<string, any>>(fields: { [K in keyof R]: Task.Maybe<R[K]>; }) => Task.Maybe<R>;
     memoize: <A>(task: Task.Maybe<A>) => Task.Maybe<A>;
   };
@@ -4032,36 +4308,83 @@ declare const Task: {
       Result: <E, A>(result: Result<E, A>) => Task.Result<E, A>;
     };
     to: {
-      Maybe: <E, A>(data: Task.Result<E, A>) => Task.Maybe<A>;
+      Maybe: <E, A>(task: Task.Result<E, A>) => Task.Maybe<A>;
     };
-    tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+    tryCatch: <E, A>(fn: (signal?: AbortSignal) => Thenable<A>, options: {
       onError: (error: unknown) => E;
     }) => Task.Result<E, A>;
-    map: <E, A, B>(f: (a: A) => B) => (data: Task.Result<E, A>) => Task.Result<E, B>;
-    mapError: <E, F, A>(f: (e: E) => F) => (data: Task.Result<E, A>) => Task.Result<F, A>;
-    chain: <E2, A, B>(f: (a: A) => Task.Result<E2, B>) => <E1 = never>(data: Task.Result<E1, A>) => Task.Result<E1 | E2, B>;
-    fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Task.Result<E, A>) => Task<B>;
+    map: <E, A, B>(transform: (value: A) => B) => (task: Task.Result<E, A>) => Task.Result<E, B>;
+    mapError: <E, F, A>(transform: (error: E) => F) => (task: Task.Result<E, A>) => Task.Result<F, A>;
+    chain: <E2, A, B>(transform: (value: A) => Task.Result<E2, B>) => <E1 = never
+    /**
+     * A lazy async computation that always resolves.
+     *
+     * Two guarantees:
+     * - **Lazy** — nothing starts until you call it.
+     * - **Infallible** — it never rejects. If failure is possible, encode it in the
+     *   return type using `Task.Result<E, A>` instead.
+     *
+     * An optional `AbortSignal` can be passed at the call site. Combinators like
+     * `retry`, `poll`, and `timeout` thread it automatically to every inner
+     * operation. Existing tasks that ignore the signal continue to work unchanged.
+     *
+     * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
+     * `await` but has no `.catch()`, `.finally()`, or chainable `.then()`.
+     *
+     * **Consuming a Task:**
+     *
+     * Use `await task()` to run it and get the value directly:
+     * ```ts
+     * const value: number = await task();
+     * ```
+     *
+     * When you need an explicit `Promise<A>` (e.g. for a third-party API), convert
+     * the `Deferred` with `Deferred.to.Promise`:
+     * ```ts
+     * const p: Promise<number> = Deferred.to.Promise(task());
+     * ```
+     *
+     * @example
+     * ```ts
+     * const getTimestamp: Task<number> = Task.make(Date.now());
+     *
+     * // Nothing runs yet — getTimestamp is just a description
+     * const formatted = pipe(
+     *   getTimestamp,
+     *   Task.map(ts => new Date(ts).toISOString())
+     * );
+     *
+     * // Execute when ready
+     * const result = await formatted();
+     * ```
+     */
+    >(task: Task.Result<E1, A>) => Task.Result<E1 | E2, B>;
+    fold: <E, A, B>(onErr: (error: E) => B, onOk: (value: A) => B) => (task: Task.Result<E, A>) => Task<B>;
     match: <E, A, B>(cases: {
-      err: (e: E) => B;
-      ok: (a: A) => B;
-    }) => (data: Task.Result<E, A>) => Task<B>;
-    recover: <E, B>(fallback: (e: E) => Task.Result<E, B>) => <A>(data: Task.Result<E, A>) => Task.Result<E, A | B>;
-    recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: (e: E) => Task.Result<E, B>) => <A>(data: Task.Result<E, A>) => Task.Result<E, A | B>;
-    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Task.Result<E, A>) => Task<A | B>;
-    tap: <E, A>(f: (a: A) => void) => (data: Task.Result<E, A>) => Task.Result<E, A>;
-    tapError: <E, A>(f: (e: E) => void) => (data: Task.Result<E, A>) => Task.Result<E, A>;
-    ap: <E, A>(arg: Task.Result<E, A>) => <B>(data: Task.Result<E, (a: A) => B>) => Task.Result<E, B>;
+      err: (error: E) => B;
+      ok: (value: A) => B;
+    }) => (task: Task.Result<E, A>) => Task<B>;
+    recover: <E1, E2, B>(fallback: (error: E1) => Task.Result<E2, B>) => <A>(task: Task.Result<E1, A>) => Task.Result<E2, A | B>;
+    recoverUnless: <E1, E2, B>(isBlocked: (error: E1) => boolean, fallback: (error: E1) => Task.Result<E2, B>) => <A>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A | B>;
+    getOrElse: <B>(fallback: () => B) => <E, A>(task: Task.Result<E, A>) => Task<A | B>;
+    tap: <E, A>(sideEffect: (value: A) => void) => (task: Task.Result<E, A>) => Task.Result<E, A>;
+    tapError: <E, A>(sideEffect: (error: E) => void) => (task: Task.Result<E, A>) => Task.Result<E, A>;
+    apply: <E2, A>(arg: Task.Result<E2, A>) => <B, E1 = never>(task: Task.Result<E1, (value: A) => B>) => Task.Result<E1 | E2, B>;
     run: (signal?: AbortSignal) => <E, A>(task: Task.Result<E, A>) => Deferred<Result<E, A>>;
-    bindTo: <K extends string>(key: K) => <E, A>(data: Task.Result<E, A>) => Task.Result<E, { [P in K]: A; }>;
-    bind: <K extends string, E, A, B>(key: K, f: (a: A) => Task.Result<E, B>) => (data: Task.Result<E, A>) => Task.Result<E, A & { [P in K]: B; }>;
+    bindTo: <K extends string>(key: K) => <E, A>(task: Task.Result<E, A>) => Task.Result<E, { [P in K]: A; }>;
+    bind: <K extends string, E2, A, B>(key: K, transform: (value: A) => Task.Result<E2, B>) => <E1 = never>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A & { [P in K]: B; }>;
     struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Result<E, R[K]>; }) => Task.Result<E, R>;
-    retry: (policy: RetryPolicy) => <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
+    retry: (policy: RetryPolicy, options?: {
+      when?: (error: unknown) => boolean;
+    }) => <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
     memoize: <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
     timeout: <E2>(options: {
       duration: Duration;
       onTimeout: () => E2;
     }) => <E1 = never, A = unknown>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A>;
     allSettled: <E, A>(tasks: ReadonlyArray<Task.Result<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
+    ensure: <A, E2>(predicate: (value: A) => boolean, onFail: (value: A) => E2) => <E1 = never>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A>;
+    bimap: <E1, E2, A, B>(onErr: (error: E1) => E2, onOk: (value: A) => B) => (task: Task.Result<E1, A>) => Task.Result<E2, B>;
   };
   Validation: {
     make: {
@@ -4076,27 +4399,27 @@ declare const Task: {
       Result: <E, A>(result: Result<E, A>) => Task.Validation<E, A>;
     };
     to: {
-      Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (data: Task.Validation<E1, A>) => Task.Result<E2, A>;
-      Maybe: <E, A>(data: Task.Validation<E, A>) => Task.Maybe<A>;
+      Result: <E1, E2, A>(combineErrors: (errors: NonEmptyArr<E1>) => E2) => (task: Task.Validation<E1, A>) => Task.Result<E2, A>;
+      Maybe: <E, A>(task: Task.Validation<E, A>) => Task.Maybe<A>;
     };
-    tryCatch: <E, A>(f: (signal?: AbortSignal) => Thenable<A>, options: {
+    tryCatch: <E, A>(fn: (signal?: AbortSignal) => Thenable<A>, options: {
       onError: (error: unknown) => E;
     }) => Task.Validation<E, A>;
-    map: <E, A, B>(f: (a: A) => B) => (data: Task.Validation<E, A>) => Task.Validation<E, B>;
-    ap: <E, A>(arg: Task.Validation<E, A>) => <B>(data: Task.Validation<E, (a: A) => B>) => Task.Validation<E, B>;
-    fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Task.Validation<E, A>) => Task<B>;
+    map: <E, A, B>(transform: (value: A) => B) => (task: Task.Validation<E, A>) => Task.Validation<E, B>;
+    apply: <E2, A>(arg: Task.Validation<E2, A>) => <B, E1 = never>(task: Task.Validation<E1, (value: A) => B>) => Task.Validation<E1 | E2, B>;
+    fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (value: A) => B) => (task: Task.Validation<E, A>) => Task<B>;
     match: <E, A, B>(cases: {
-      passed: (a: A) => B;
+      passed: (value: A) => B;
       failed: (errors: NonEmptyArr<E>) => B;
-    }) => (data: Task.Validation<E, A>) => Task<B>;
-    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: Task.Validation<E, A>) => Task<A | B>;
-    tap: <E, A>(f: (a: A) => void) => (data: Task.Validation<E, A>) => Task.Validation<E, A>;
-    recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Task.Validation<E, B>) => <A>(data: Task.Validation<E, A>) => Task.Validation<E, A | B>;
-    recoverUnless: <E, B>(isBlocked: (errors: NonEmptyArr<E>) => boolean, fallback: (errors: NonEmptyArr<E>) => Task.Validation<E, B>) => <A>(data: Task.Validation<E, A>) => Task.Validation<E, A | B>;
+    }) => (task: Task.Validation<E, A>) => Task<B>;
+    getOrElse: <B>(fallback: () => B) => <E, A>(task: Task.Validation<E, A>) => Task<A | B>;
+    tap: <E, A>(sideEffect: (value: A) => void) => (task: Task.Validation<E, A>) => Task.Validation<E, A>;
+    recover: <E1, E2, B>(fallback: (errors: NonEmptyArr<E1>) => Task.Validation<E2, B>) => <A>(task: Task.Validation<E1, A>) => Task.Validation<E2, A | B>;
+    recoverUnless: <E1, E2, B>(isBlocked: (errors: NonEmptyArr<E1>) => boolean, fallback: (errors: NonEmptyArr<E1>) => Task.Validation<E2, B>) => <A>(task: Task.Validation<E1, A>) => Task.Validation<E1 | E2, A | B>;
     product: <E, A, B>(first: Task.Validation<E, A>, second: Task.Validation<E, B>) => Task.Validation<E, readonly [A, B]>;
-    productAll: <E, A>(data: NonEmptyArr<Task.Validation<E, A>>) => Task.Validation<E, readonly A[]>;
-    mapError: <E, F, A>(f: (e: E) => F) => (data: Task.Validation<E, A>) => Task.Validation<F, A>;
-    tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: Task.Validation<E, A>) => Task.Validation<E, A>;
+    productAll: <E, A>(validations: NonEmptyArr<Task.Validation<E, A>>) => Task.Validation<E, readonly A[]>;
+    mapError: <E, F, A>(transform: (error: E) => F) => (task: Task.Validation<E, A>) => Task.Validation<F, A>;
+    tapError: <E, A>(sideEffect: (errors: NonEmptyArr<E>) => void) => (task: Task.Validation<E, A>) => Task.Validation<E, A>;
     struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Validation<E, R[K]>; }) => Task.Validation<E, R>;
     memoize: <E, A>(task: Task.Validation<E, A>) => Task.Validation<E, A>;
   };
@@ -4169,7 +4492,7 @@ declare const These: {
      * These.make.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
      * ```
      */
-    both: <A, B>(f: A, s: B) => TheseBoth<A, B>;
+    both: <A, B>(first: A, second: B) => TheseBoth<A, B>;
   };
   is: {
     /**
@@ -4183,7 +4506,7 @@ declare const These: {
      * }
      * ```
      */
-    first: <A, B>(data: These<A, B>) => data is TheseFirst<A>;
+    first: <A, B>(these: These<A, B>) => these is TheseFirst<A>;
     /**
      * Type guard — checks if a These holds only a second value.
      *
@@ -4195,7 +4518,7 @@ declare const These: {
      * }
      * ```
      */
-    second: <A, B>(data: These<A, B>) => data is TheseSecond<B>;
+    second: <A, B>(these: These<A, B>) => these is TheseSecond<B>;
     /**
      * Type guard — checks if a These holds both values simultaneously.
      *
@@ -4207,11 +4530,13 @@ declare const These: {
      * }
      * ```
      */
-    both: <A, B>(data: These<A, B>) => data is TheseBoth<A, B>;
+    both: <A, B>(these: These<A, B>) => these is TheseBoth<A, B>;
   };
   /**
    * 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
@@ -4219,10 +4544,12 @@ declare const These: {
    * These.hasFirst(These.make.second("warn"));  // false
    * ```
    */
-  hasFirst: <A, B>(data: These<A, B>) => data is TheseFirst<A> | TheseBoth<A, B>;
+  hasFirst: <A, B>(these: These<A, B>) => these is TheseFirst<A> | TheseBoth<A, B>;
   /**
    * 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
@@ -4230,10 +4557,13 @@ declare const These: {
    * These.hasSecond(These.make.first(42));       // false
    * ```
    */
-  hasSecond: <A, B>(data: These<A, B>) => data is TheseSecond<B> | TheseBoth<A, B>;
+  hasSecond: <A, B>(these: These<A, B>) => these is TheseSecond<B> | TheseBoth<A, B>;
   /**
    * 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)
@@ -4241,20 +4571,26 @@ declare const These: {
    * pipe(These.make.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
    * ```
    */
-  mapFirst: <A, C>(f: (a: A) => C) => <B>(data: These<A, B>) => These<C, B>;
+  mapFirst: <A, C>(transform: (first: A) => C) => <B>(these: These<A, B>) => These<C, B>;
   /**
    * 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: <B, D>(f: (b: B) => D) => <A>(data: These<A, B>) => These<A, D>;
+  mapSecond: <B, D>(transform: (second: B) => D) => <A>(these: These<A, B>) => These<A, D>;
   /**
    * 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(
@@ -4263,10 +4599,12 @@ declare const These: {
    * ); // Both(10, "WARN")
    * ```
    */
-  mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (data: These<A, B>) => These<C, D>;
+  mapBoth: <A, C, B, D>(onFirst: (first: A) => C, onSecond: (second: B) => D) => (these: These<A, B>) => These<C, D>;
   /**
-   * 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
@@ -4277,10 +4615,12 @@ declare const These: {
    * pipe(These.make.second("warn"), These.chainFirst(double));      // Second("warn")
    * ```
    */
-  chainFirst: <A, B, C>(f: (a: A) => These<C, B>) => (data: These<A, B>) => These<C, B>;
+  chainFirst: <A, B, C>(transform: (first: A) => These<C, B>) => (these: These<A, B>) => These<C, B>;
   /**
-   * 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
@@ -4291,10 +4631,12 @@ declare const These: {
    * pipe(These.make.first(5), These.chainSecond(shout));            // First(5)
    * ```
    */
-  chainSecond: <A, B, D>(f: (b: B) => These<A, D>) => (data: These<A, B>) => These<A, D>;
+  chainSecond: <A, B, D>(transform: (second: B) => These<A, D>) => (these: These<A, B>) => These<A, D>;
   /**
    * 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(
@@ -4307,10 +4649,12 @@ declare const These: {
    * );
    * ```
    */
-  fold: <A, B, C>(onFirst: (a: A) => C, onSecond: (b: B) => C, onBoth: (a: A, b: B) => C) => (data: These<A, B>) => C;
+  fold: <A, B, C>(onFirst: (first: A) => C, onSecond: (second: B) => C, onBoth: (first: A, second: B) => C) => (these: These<A, B>) => C;
   /**
    * Pattern matches on a These, returning the result of the matching case.
    *
+   * @see {@link These.fold} for positional argument pattern matching.
+   *
    * @example
    * ```ts
    * pipe(
@@ -4324,14 +4668,16 @@ declare const These: {
    * ```
    */
   match: <A, B, C>(cases: {
-    first: (a: A) => C;
-    second: (b: B) => C;
-    both: (a: A, b: B) => C;
-  }) => (data: These<A, B>) => C;
+    first: (first: A) => C;
+    second: (second: B) => C;
+    both: (first: A, second: B) => C;
+  }) => (these: These<A, B>) => C;
   /**
    * 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
@@ -4340,11 +4686,13 @@ declare const These: {
    * pipe(These.make.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
    * ```
    */
-  getFirstOrElse: <A, C>(defaultValue: () => C) => <B>(data: These<A, B>) => A | C;
+  getFirstOrElse: <A, C>(fallback: () => C) => <B>(these: These<A, B>) => A | C;
   /**
    * 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"
@@ -4353,7 +4701,7 @@ declare const These: {
    * pipe(These.make.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
    * ```
    */
-  getSecondOrElse: <B, D>(defaultValue: () => D) => <A>(data: These<A, B>) => B | D;
+  getSecondOrElse: <B, D>(fallback: () => D) => <A>(these: These<A, B>) => B | D;
   /**
    * Runs a side effect on the first value without changing the These.
    * Useful for logging or debugging.
@@ -4363,7 +4711,7 @@ declare const These: {
    * pipe(These.make.first(5), These.tap(console.log)); // logs 5, returns First(5)
    * ```
    */
-  tap: <A>(f: (a: A) => void) => <B>(data: These<A, B>) => These<A, B>;
+  tap: <A>(sideEffect: (first: A) => void) => <B>(these: These<A, B>) => These<A, B>;
   /**
    * Swaps the roles of first and second values.
    * - First(a)    → Second(a)
@@ -4377,7 +4725,7 @@ declare const These: {
    * These.swap(These.make.both(5, "warn"));     // Both("warn", 5)
    * ```
    */
-  swap: <A, B>(data: These<A, B>) => These<B, A>;
+  swap: <A, B>(these: These<A, B>) => These<B, A>;
 };
 //#endregion
-export { Logged as A, Pair as C, Maybe as D, Op as E, Lazy as M, Equality as N, None as O, Combinable as P, Predicate as S, Optional as T, NotAsked as _, Task as a, Refinement as b, Validation as c, Err$1 as d, Ok$1 as f, Loading as g, Failure as h, TheseSecond as i, Lens as j, Some as k, Stream as l, Resource as m, TheseBoth as n, Failed as o, Result as p, TheseFirst as r, Passed as s, These as t, State$1 as u, RemoteData as v, Ordering as w, Reader as x, Success as y };
+export { Lens as A, Ordering as C, None as D, Maybe as E, EventBus as M, Equality as N, Some as O, Combinable as P, Pair as S, Op as T, RemoteData as _, Task as a, Reader as b, Validation as c, Ok$1 as d, Result as f, NotAsked as g, Loading as h, TheseSecond as i, Lazy as j, Logged as k, State$1 as l, Failure as m, TheseBoth as n, Failed as o, Resource as p, TheseFirst as r, Passed as s, These as t, Err$1 as u, Success as v, Optional as w, Predicate as x, Refinement as y };