@nlozgachev/pipelined 0.64.0 → 0.66.0

package/dist/index-8A9NqJTq.d.cts

@@ -0,0 +1,4420 @@
+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";
+//#region src/Core/Combinable.d.ts
+/**
+ * A type that can combine two values of type `A` into one, with a neutral starting value.
+ * `empty` is the identity: `combine(empty)(a) === a` and `combine(a)(empty) === a`.
+ * `combine(b)(a)` appends `b` onto `a` — `a` is the accumulated value, `b` is the new element.
+ *
+ * @example
+ * ```ts
+ * pipe(["hello", ", ", "world"], Combinable.fold(Combinable.string)); // "hello, world"
+ * pipe([1, 2, 3, 4, 5], Combinable.fold(Combinable.sum));            // 15
+ * ```
+ */
+type Combinable<A> = {
+  readonly empty: A;
+  readonly combine: (b: A) => (a: A) => A;
+};
+declare const Combinable: {
+  /**
+   * Combines strings by concatenation. Empty string is the neutral element.
+   *
+   * @example
+   * ```ts
+   * pipe(["a", "b", "c"], Combinable.fold(Combinable.string)); // "abc"
+   * ```
+   */
+  string: Combinable<string>;
+  /**
+   * Combines numbers by addition. `0` is the neutral element.
+   *
+   * @example
+   * ```ts
+   * pipe([1, 2, 3], Combinable.fold(Combinable.sum)); // 6
+   * ```
+   */
+  sum: Combinable<number>;
+  /**
+   * Combines numbers by multiplication. `1` is the neutral element.
+   *
+   * @example
+   * ```ts
+   * pipe([2, 3, 4], Combinable.fold(Combinable.product)); // 24
+   * ```
+   */
+  product: Combinable<number>;
+  /**
+   * Combines booleans with logical AND. `true` is the neutral element.
+   *
+   * @example
+   * ```ts
+   * pipe([true, true, false], Combinable.fold(Combinable.all)); // false
+   * ```
+   */
+  all: Combinable<boolean>;
+  /**
+   * Combines booleans with logical OR. `false` is the neutral element.
+   *
+   * @example
+   * ```ts
+   * pipe([false, false, true], Combinable.fold(Combinable.any)); // true
+   * ```
+   */
+  any: Combinable<boolean>;
+  /**
+   * Combines arrays by concatenation. Empty array is the neutral element.
+   *
+   * @example
+   * ```ts
+   * pipe([[1, 2], [3], [4, 5]], Combinable.fold(Combinable.array<number>())); // [1, 2, 3, 4, 5]
+   * ```
+   */
+  array: <A>() => Combinable<readonly A[]>;
+  /**
+   * Lifts a `Combinable<A>` to `Combinable<Maybe<A>>`. `None` is the neutral element —
+   * combining with `None` on either side returns the other value unchanged.
+   * Two `Some` values combine their inner values using the inner `Combinable`.
+   *
+   * @example
+   * ```ts
+   * const c = Combinable.maybe(Combinable.sum);
+   * c.combine(Maybe.make.some(3))(Maybe.make.some(2)); // Some(5)
+   * c.combine(Maybe.make.none())(Maybe.make.some(5));  // Some(5)
+   * ```
+   */
+  maybe: <A>(inner: Combinable<A>) => Combinable<Maybe<A>>;
+  /**
+   * Folds an array into a single value using the `Combinable`'s `empty` as the starting point.
+   *
+   * @example
+   * ```ts
+   * pipe([1, 2, 3, 4, 5], Combinable.fold(Combinable.sum)); // 15
+   * pipe([], Combinable.fold(Combinable.sum));               // 0
+   * ```
+   */
+  fold: <A>(c: Combinable<A>) => (data: readonly A[]) => A;
+  /**
+   * Derives a `Combinable` for a record of fields from field-level `Combinable` instances.
+   *
+   * @example
+   * ```ts
+   * const StatsCombinable = Combinable.struct({
+   *   count: Combinable.sum,
+   *   tags: Combinable.array<string>(),
+   * });
+   * ```
+   */
+  struct: <R extends Record<string, unknown>>(fields: { [K in keyof R]: Combinable<R[K]>; }) => Combinable<R>;
+};
+//#endregion
+//#region src/Core/Equality.d.ts
+/**
+ * A function that checks whether two values of type `A` are equal.
+ * Use built-in instances (`Equality.string`, `Equality.number`, etc.) as starting points,
+ * then adapt them with `Equality.by` and combine them with `Equality.and`.
+ *
+ * @example
+ * ```ts
+ * type User = { id: string; name: string };
+ * const byId = pipe(Equality.string, Equality.by((u: User) => u.id));
+ *
+ * pipe(users, Arr.uniqWith(byId));
+ * ```
+ */
+type Equality<A> = (a: A, b: A) => boolean;
+declare const Equality: {
+  /**
+   * Equality for strings. Case-sensitive.
+   *
+   * @example
+   * ```ts
+   * Equality.string("hello", "hello"); // true
+   * Equality.string("hello", "Hello"); // false
+   * ```
+   */
+  string: Equality<string>;
+  /**
+   * Equality for numbers. Uses strict equality.
+   *
+   * @example
+   * ```ts
+   * Equality.number(42, 42); // true
+   * ```
+   */
+  number: Equality<number>;
+  /**
+   * Equality for booleans.
+   *
+   * @example
+   * ```ts
+   * Equality.boolean(true, true); // true
+   * ```
+   */
+  boolean: Equality<boolean>;
+  /**
+   * Equality for `Date` values. Compares by numeric time value.
+   *
+   * @example
+   * ```ts
+   * Equality.date(new Date("2024-01-01"), new Date("2024-01-01")); // true
+   * ```
+   */
+  date: Equality<Date>;
+  /**
+   * Lifts an element equality into an array equality. Two arrays are equal if they have the
+   * same length and every element pair is equal under `eq`.
+   *
+   * @example
+   * ```ts
+   * Equality.array(Equality.number)([1, 2, 3], [1, 2, 3]); // true
+   * ```
+   */
+  array: <A>(eq: Equality<A>) => Equality<readonly A[]>;
+  /**
+   * Adapts an equality for type `A` into an equality for type `B` by extracting a field.
+   * Read as "equality by this field": `pipe(Equality.string, Equality.by(u => u.name))`.
+   *
+   * @example
+   * ```ts
+   * type Product = { id: string; price: number };
+   * const byId = pipe(Equality.string, Equality.by((p: Product) => p.id));
+   * byId({ id: "p1", price: 9 }, { id: "p1", price: 12 }); // true
+   * ```
+   */
+  by: <A, B>(f: (b: B) => A) => (eq: Equality<A>) => Equality<B>;
+  /**
+   * Combines two equalities with logical AND. Both must pass for two values to be considered equal.
+   * Data-last: the first equality is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const exact = pipe(byName, Equality.and(byRole));
+   * exact(userA, userB); // true only if name AND role match
+   * ```
+   */
+  and: <A>(eq2: Equality<A>) => (eq1: Equality<A>) => Equality<A>;
+  /**
+   * Derives deep equality for a record from field-level `Equality` checkers.
+   *
+   * @example
+   * ```ts
+   * const userEq = Equality.struct({
+   *   id: Equality.string,
+   *   age: Equality.number,
+   * });
+   * ```
+   */
+  struct: <R extends Record<string, unknown>>(fields: { [K in keyof R]: Equality<R[K]>; }) => Equality<R>;
+  /**
+   * Derives element-wise equality for a tuple from positional `Equality` checkers.
+   *
+   * @example
+   * ```ts
+   * const pairEq = Equality.tuple(Equality.string, Equality.number);
+   * pairEq(["a", 1], ["a", 1]); // true
+   * ```
+   */
+  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 —
+ * on the first call to `Lazy.evaluate` — and the result is cached for all subsequent calls.
+ *
+ * @example
+ * ```ts
+ * const config = Lazy.from(() => parseConfig(rawInput));
+ *
+ * pipe(
+ *   config,
+ *   Lazy.map(cfg => cfg.port),
+ *   Lazy.evaluate,
+ * ); // parseConfig ran once; cfg.port returned
+ * ```
+ */
+type Lazy<A> = {
+  readonly get: () => A;
+};
+declare const Lazy: {
+  /**
+   * Wraps a thunk in a `Lazy`. The thunk runs exactly once, on first `evaluate`.
+   *
+   * @example
+   * ```ts
+   * const expensive = Lazy.from(() => computeExpensiveValue(input));
+   * ```
+   */
+  from: <A>(f: () => A) => Lazy<A>;
+  /**
+   * Forces evaluation and returns the cached result. Safe to call multiple times.
+   *
+   * @example
+   * ```ts
+   * const value = Lazy.evaluate(Lazy.from(() => 42)); // 42
+   * ```
+   */
+  evaluate: <A>(lazy: Lazy<A>) => A;
+  /**
+   * Transforms the result of a `Lazy` without triggering evaluation.
+   *
+   * @example
+   * ```ts
+   * pipe(Lazy.from(() => loadConfig()), Lazy.map(cfg => cfg.port));
+   * ```
+   */
+  map: <A, B>(f: (a: A) => B) => (lazy: Lazy<A>) => Lazy<B>;
+  /**
+   * Chains a `Lazy`-returning transformation without triggering evaluation.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Lazy.from(() => loadConfig()),
+   *   Lazy.chain(cfg => Lazy.from(() => openConnection(cfg.dbUrl))),
+   * );
+   * ```
+   */
+  chain: <A, B>(f: (a: A) => Lazy<B>) => (lazy: Lazy<A>) => Lazy<B>;
+  /**
+   * Runs a side effect on the value without changing it. Fires once, on first `evaluate`.
+   *
+   * @example
+   * ```ts
+   * pipe(Lazy.from(() => compute()), Lazy.tap(v => console.log("computed:", v)));
+   * ```
+   */
+  tap: <A>(f: (a: A) => void) => (lazy: Lazy<A>) => Lazy<A>;
+};
+//#endregion
+//#region src/Core/Lens.d.ts
+/**
+ * Lens<S, A> focuses on a single value A inside a structure S, providing
+ * a composable way to read and immutably update nested data.
+ *
+ * A Lens always succeeds: the focused value is guaranteed to exist.
+ * For optional or indexed focuses, use Optional<S, A>.
+ *
+ * @example
+ * ```ts
+ * type Address = { city: string; zip: string };
+ * type User = { name: string; address: Address };
+ *
+ * const addressLens = Lens.from.property<User>()("address");
+ * const cityLens    = Lens.from.property<Address>()("city");
+ * const userCityLens = pipe(addressLens, Lens.andThen(cityLens));
+ *
+ * pipe(user, Lens.get(userCityLens));             // "Berlin"
+ * pipe(user, Lens.set(userCityLens)("Hamburg"));  // new User with city updated
+ * pipe(user, Lens.modify(userCityLens)(c => c.toUpperCase())); // "BERLIN"
+ * ```
+ */
+type Lens<S, A> = {
+  readonly get: (s: S) => A;
+  readonly set: (a: A) => (s: S) => S;
+};
+declare const Lens: {
+  from: {
+    /**
+     * Constructs a Lens from a getter and a setter.
+     *
+     * @example
+     * ```ts
+     * const nameLens = Lens.from.accessors(
+     *   (user: User) => user.name,
+     *   (name) => (user) => ({ ...user, name }),
+     * );
+     * ```
+     */
+    accessors: <S, A>(get: (s: S) => A, set: (a: A) => (s: S) => S) => Lens<S, A>;
+    /**
+     * Creates a Lens that focuses on a property of an object.
+     * Call with the structure type first, then the key.
+     *
+     * @example
+     * ```ts
+     * const nameLens = Lens.from.property<User>()("name");
+     * ```
+     */
+    property: <S>() => <K extends keyof S>(key: K) => Lens<S, S[K]>;
+  };
+  /**
+   * Reads the focused value from a structure.
+   *
+   * @example
+   * ```ts
+   * pipe(user, Lens.get(nameLens)); // "Alice"
+   * ```
+   */
+  get: <S, A>(lens: Lens<S, A>) => (s: S) => A;
+  /**
+   * Replaces the focused value within a structure, returning a new structure.
+   *
+   * @example
+   * ```ts
+   * pipe(user, Lens.set(nameLens)("Bob")); // new User with name "Bob"
+   * ```
+   */
+  set: <S, A>(lens: Lens<S, A>) => (a: A) => (s: S) => S;
+  /**
+   * Applies a function to the focused value, returning a new structure.
+   *
+   * @example
+   * ```ts
+   * pipe(user, Lens.modify(nameLens)(n => n.toUpperCase())); // "ALICE"
+   * ```
+   */
+  modify: <S, A>(lens: Lens<S, A>) => (f: (a: A) => A) => (s: S) => S;
+  /**
+   * Composes two Lenses: focuses through the outer, then through the inner.
+   * Use in a pipe chain to build up a deep focus step by step.
+   *
+   * @example
+   * ```ts
+   * const userCityLens = pipe(
+   *   Lens.from.property<User>()("address"),
+   *   Lens.andThen(Lens.from.property<Address>()("city")),
+   * );
+   * ```
+   */
+  andThen: <A, B>(inner: Lens<A, B>) => <S>(outer: Lens<S, A>) => Lens<S, B>;
+  /**
+   * Composes a Lens with an Optional, producing an Optional.
+   * Use when the next step in the focus is optional (may be absent).
+   *
+   * @example
+   * ```ts
+   * const userBioOpt = pipe(
+   *   Lens.from.property<User>()("profile"),
+   *   Lens.andThenOptional(Optional.from.property<Profile>()("bio")),
+   * );
+   * ```
+   */
+  andThenOptional: <A, B>(inner: Optional<A, B>) => <S>(outer: Lens<S, A>) => Optional<S, B>;
+  /**
+   * Converts a Lens to an Optional. Every Lens is a valid Optional
+   * whose get always returns Some.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Lens.from.property<User>()("address"),
+   *   Lens.toOptional,
+   *   Optional.andThen(Optional.from.property<Address>()("landmark")),
+   * );
+   * ```
+   */
+  toOptional: <S, A>(lens: Lens<S, A>) => Optional<S, A>;
+};
+//#endregion
+//#region src/Core/Logged.d.ts
+/**
+ * A value paired with an accumulated log.
+ *
+ * `Logged<W, A>` pairs a result `A` with a sequence of log entries `W`. When
+ * you sequence two `Logged` computations with `chain`, the logs are
+ * automatically concatenated — you never have to thread the log array through
+ * your code manually.
+ *
+ * @example
+ * ```ts
+ * const program = pipe(
+ *   Logged.from.value<string, number>(0),
+ *   Logged.chain(n => pipe(
+ *     Logged.from.entry("start"),
+ *     Logged.map(() => n + 1),
+ *   )),
+ *   Logged.chain(n => pipe(
+ *     Logged.from.entry("done"),
+ *     Logged.map(() => n * 10),
+ *   )),
+ * );
+ *
+ * Logged.run(program); // [10, ["start", "done"]]
+ * ```
+ */
+type Logged<L, A> = WithValue<A> & WithLog<L>;
+declare const Logged: {
+  from: {
+    /**
+     * Wraps a pure value into a `Logged` with an empty log.
+     *
+     * @example
+     * ```ts
+     * Logged.from.value<string, number>(42); // { value: 42, log: [] }
+     * ```
+     */
+    value: <W, A>(val: A) => Logged<W, A>;
+    /**
+     * Creates a `Logged` that records a single log entry and produces no
+     * meaningful value. Use this to append to the log inside a `chain`.
+     *
+     * @example
+     * ```ts
+     * Logged.from.entry("operation completed"); // { value: undefined, log: ["operation completed"] }
+     * ```
+     */
+    entry: <W>(logEntry: W) => Logged<W, undefined>;
+  };
+  /**
+   * Transforms the value inside a `Logged` without affecting the log.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Logged.from.value<string, number>(5),
+   *   Logged.map(n => n * 2),
+   * ); // { value: 10, log: [] }
+   * ```
+   */
+  map: <W, A, B>(f: (a: A) => B) => (data: Logged<W, A>) => Logged<W, B>;
+  /**
+   * Sequences two `Logged` computations, concatenating their logs.
+   * The value from the first is passed to `f`; the resulting log entries are
+   * appended after the entries from the first.
+   *
+   * Data-last — the first computation is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const result = pipe(
+   *   Logged.from.value<string, number>(1),
+   *   Logged.chain(n => pipe(Logged.from.entry("step"), Logged.map(() => n + 1))),
+   *   Logged.chain(n => pipe(Logged.from.entry("done"), Logged.map(() => n * 10))),
+   * );
+   *
+   * Logged.run(result); // [20, ["step", "done"]]
+   * ```
+   */
+  chain: <W, A, B>(f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, B>;
+  /**
+   * Applies a function wrapped in a `Logged` to a value wrapped in a `Logged`,
+   * concatenating both logs.
+   *
+   * @example
+   * ```ts
+   * const fn: Logged<string, (n: number) => number> = {
+   *   value: n => n * 2,
+   *   log: ["fn-loaded"],
+   * };
+   * const arg: Logged<string, number> = { value: 5, log: ["arg-loaded"] };
+   *
+   * const result = pipe(fn, Logged.ap(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>;
+  /**
+   * Runs a side effect on the value without changing the `Logged`.
+   * Useful for debugging or inspecting intermediate values.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Logged.from.value<string, number>(42),
+   *   Logged.tap(n => console.log("value:", n)),
+   * );
+   * ```
+   */
+  tap: <W, A>(f: (a: A) => void) => (data: Logged<W, A>) => Logged<W, A>;
+  /**
+   * Extracts the value and log as a `readonly [A, ReadonlyArray<W>]` tuple.
+   * Use this at the boundary where you need to consume both.
+   *
+   * @example
+   * ```ts
+   * const result = pipe(
+   *   Logged.from.value<string, number>(1),
+   *   Logged.chain(n => pipe(Logged.from.entry("incremented"), Logged.map(() => n + 1))),
+   * );
+   *
+   * const [value, log] = Logged.run(result);
+   * // value = 2, log = ["incremented"]
+   * ```
+   */
+  run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+  /**
+   * Lifts a Logged value into an accumulator object.
+   *
+   * @example
+   * ```ts
+   * pipe(Logged.from.value<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
+   * ```
+   */
+  bindTo: <K extends string>(key: K) => <W, A>(data: Logged<W, A>) => Logged<W, { [P in K]: A; }>;
+  /**
+   * Evaluates a new Logged using the current accumulator and attaches the output to a new key.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Logged.from.value<string, { a: number }>({ a: 1 }),
+   *   Logged.bind("b", ({ a }) => Logged.from.value<string, number>(a + 1))
+   * ); // Logged({ value: { a: 1, b: 2 } })
+   * ```
+   */
+  bind: <K extends string, W, A, B>(key: K, f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, A & { [P in K]: B; }>;
+  /**
+   * Focuses a Logged computation's value transformation using a Lens.
+   *
+   * @example
+   * ```ts
+   * const nameLens = Lens.from.property<{ name: string }>()("name");
+   * const logged = Logged.from.value<string, { name: string }>({ name: "alice" });
+   * pipe(logged, Logged.focus(nameLens)(s => s.toUpperCase()));
+   * ```
+   */
+  focus: <S, A>(lens: Lens<S, A>) => <W>(f: (a: A) => A) => (data: Logged<W, S>) => Logged<W, S>;
+};
+//#endregion
+//#region src/Core/Maybe.d.ts
+/**
+ * Maybe represents an optional value: every Maybe is either Some (contains a value) or None (empty).
+ * Use Maybe instead of null/undefined to make optionality explicit and composable.
+ *
+ * @example
+ * ```ts
+ * const user = { name: "Alice", email: Maybe.make.some("alice@example.com") };
+ *
+ * pipe(
+ *   user.email,
+ *   Maybe.map(email => email.toUpperCase()),
+ *   Maybe.getOrElse(() => "NO EMAIL")
+ * ); // "ALICE@EXAMPLE.COM"
+ * ```
+ */
+type Maybe<T> = Some<T> | None;
+type Some<A> = WithKind<"Some"> & WithValue<A>;
+type None = WithKind<"None">;
+declare const Maybe: {
+  make: {
+    /**
+     * Creates a Some containing the given value.
+     *
+     * @example
+     * ```ts
+     * Maybe.make.some(42); // Some(42)
+     * ```
+     */
+    some: <A>(value: A) => Some<A>;
+    /**
+     * Creates a None (empty Maybe).
+     *
+     * @example
+     * ```ts
+     * Maybe.make.none(); // None
+     * ```
+     */
+    none: () => None;
+  };
+  is: {
+    /**
+     * Type guard that checks if a Maybe is Some.
+     *
+     * @example
+     * ```ts
+     * const value = Maybe.make.some(42);
+     * if (Maybe.is.some(value)) {
+     *   console.log(value.value); // 42
+     * }
+     * ```
+     */
+    some: <A>(data: Maybe<A>) => data is Some<A>;
+    /**
+     * Type guard that checks if a Maybe is None.
+     *
+     * @example
+     * ```ts
+     * const value = Maybe.make.none();
+     * if (Maybe.is.none(value)) {
+     *   console.log("No value present");
+     * }
+     * ```
+     */
+    none: <A>(data: Maybe<A>) => data is None;
+  };
+  to: {
+    /**
+     * Extracts the value from a Maybe, returning null if None.
+     *
+     * @example
+     * ```ts
+     * Maybe.to.nullable(Maybe.make.some(42)); // 42
+     * Maybe.to.nullable(Maybe.make.none());   // null
+     * ```
+     */
+    nullable: <A>(data: Maybe<A>) => A | null;
+    /**
+     * Extracts the value from a Maybe, returning undefined if None.
+     *
+     * @example
+     * ```ts
+     * Maybe.to.undefined(Maybe.make.some(42)); // 42
+     * Maybe.to.undefined(Maybe.make.none());   // undefined
+     * ```
+     */
+    undefined: <A>(data: Maybe<A>) => A | undefined;
+    /**
+     * Converts a Maybe to a Result.
+     * Some becomes Ok, None becomes Err with the provided error.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Maybe.make.some(42),
+     *   Maybe.to.Result(() => "Value was missing")
+     * ); // Ok(42)
+     *
+     * pipe(
+     *   Maybe.make.none(),
+     *   Maybe.to.Result(() => "Value was missing")
+     * ); // Err("Value was missing")
+     * ```
+     */
+    Result: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Result<E, A>;
+  };
+  from: {
+    /**
+     * Creates a Maybe from a nullable value.
+     * Returns None if the value is null or undefined, Some otherwise.
+     *
+     * @example
+     * ```ts
+     * Maybe.from.nullable(null); // None
+     * Maybe.from.nullable(42); // Some(42)
+     * ```
+     */
+    nullable: <A>(value: A | null | undefined) => Maybe<A>;
+    /**
+     * Creates a Maybe from a predicate applied to a value.
+     * Returns Some if the predicate passes, None otherwise.
+     *
+     * @example
+     * ```ts
+     * Maybe.from.Predicate((n: number) => n >= 18)(21); // Some(21)
+     * Maybe.from.Predicate((n: number) => n >= 18)(15); // None
+     *
+     * pipe("hello", Maybe.from.Predicate((s: string) => s.length > 0)); // Some("hello")
+     * pipe("", Maybe.from.Predicate((s: string) => s.length > 0));      // None
+     * ```
+     */
+    Predicate: <A>(pred: (a: A) => boolean) => (a: A) => Maybe<A>;
+    /**
+     * Creates a Maybe from a Result.
+     * Ok becomes Some, Err becomes None (the error is discarded).
+     *
+     * @example
+     * ```ts
+     * Maybe.from.Result(Result.make.ok(42)); // Some(42)
+     * Maybe.from.Result(Result.make.err("oops")); // None
+     * ```
+     */
+    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.
+   *
+   * @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>;
+  /**
+   * Chains Maybe computations. If the first is Some, passes the value to f.
+   * If the first is None, propagates None.
+   *
+   * @example
+   * ```ts
+   * const parseNumber = (s: string): Maybe<number> => {
+   *   const n = parseInt(s, 10);
+   *   return isNaN(n) ? Maybe.make.none() : Maybe.make.some(n);
+   * };
+   *
+   * pipe(Maybe.make.some("42"), Maybe.chain(parseNumber)); // Some(42)
+   * pipe(Maybe.make.some("abc"), Maybe.chain(parseNumber)); // None
+   * ```
+   */
+  chain: <A, B>(f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<B>;
+  /**
+   * Extracts the value from a Maybe by providing handlers for both cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.some(5),
+   *   Maybe.fold(
+   *     () => "No value",
+   *     n => `Value: ${n}`
+   *   )
+   * ); // "Value: 5"
+   * ```
+   */
+  fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: Maybe<A>) => B;
+  /**
+   * Pattern matches on a Maybe, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   optionUser,
+   *   Maybe.match({
+   *     some: user => `Hello, ${user.name}`,
+   *     none: () => "Hello, stranger"
+   *   })
+   * );
+   * ```
+   */
+  match: <A, B>(cases: {
+    none: () => B;
+    some: (a: A) => B;
+  }) => (data: 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`.
+   *
+   * @example
+   * ```ts
+   * pipe(Maybe.make.some(5), Maybe.getOrElse(() => 0)); // 5
+   * pipe(Maybe.make.none(), Maybe.getOrElse(() => 0)); // 0
+   * pipe(Maybe.make.none<string>(), Maybe.getOrElse(() => null)); // null — typed as string | null
+   * ```
+   */
+  getOrElse: <B>(defaultValue: () => B) => <A>(data: Maybe<A>) => A | B;
+  /**
+   * Executes a side effect on the value without changing the Maybe.
+   * Useful for logging or debugging.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.some(5),
+   *   Maybe.tap(n => console.log("Value:", n)),
+   *   Maybe.map(n => n * 2)
+   * );
+   * ```
+   */
+  tap: <A>(f: (a: A) => void) => (data: Maybe<A>) => Maybe<A>;
+  /**
+   * Executes a side effect when the Maybe is None, without changing the Maybe.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.none(),
+   *   Maybe.tapNone(() => console.log("Value missing")),
+   * );
+   * ```
+   */
+  tapNone: (f: () => void) => <A>(data: Maybe<A>) => Maybe<A>;
+  /**
+   * Filters a Maybe based on a predicate or type guard.
+   * Returns None if the predicate returns false or if the Maybe is already None.
+   *
+   * @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, B extends A>(refinement: (a: A) => a is B): (data: Maybe<A>) => Maybe<B>;
+    <A>(predicate: (a: A) => boolean): (data: 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>`.
+   *
+   * @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>;
+  /**
+   * Applies a function wrapped in a Maybe to a value wrapped in a Maybe.
+   *
+   * @example
+   * ```ts
+   * 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))
+   * ); // Some(8)
+   * ```
+   */
+  ap: <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.
+   *
+   * @example
+   * ```ts
+   * pipe(Maybe.make.some(42), Maybe.bindTo("value")); // Some({ value: 42 })
+   * ```
+   */
+  bindTo: <K extends string>(key: K) => <A>(data: Maybe<A>) => Maybe<{ [P in K]: A; }>;
+  /**
+   * Evaluates a new Maybe using the current accumulator and attaches the output to a new key.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.some({ a: 1 }),
+   *   Maybe.bind("b", ({ a }) => Maybe.make.some(a + 1))
+   * ); // Some({ a: 1, b: 2 })
+   * ```
+   */
+  bind: <K extends string, A, B>(key: K, f: (a: A) => Maybe<B>) => (data: Maybe<A>) => Maybe<A & { [P in K]: B; }>;
+  /**
+   * Combines a record of Maybes into a single Maybe of a record.
+   * Evaluates fields in key order and short-circuits on the first None.
+   *
+   * @example
+   * ```ts
+   * Maybe.struct({
+   *   name: Maybe.make.some("Alice"),
+   *   age: Maybe.make.some(30)
+   * }); // Some({ name: "Alice", age: 30 })
+   * ```
+   */
+  struct: <R extends Record<string, any>>(fields: { [K in keyof R]: Maybe<R[K]>; }) => Maybe<R>;
+  /**
+   * Swaps the outer `Maybe` and inner `Result` context.
+   * `Some(Ok(a))` becomes `Ok(Some(a))`, `Some(Err(e))` becomes `Err(e)`, and `None` becomes `Ok(None)`.
+   *
+   * @example
+   * ```ts
+   * Maybe.transposeResult(Maybe.make.some(Result.make.ok(42)));  // Ok(Some(42))
+   * Maybe.transposeResult(Maybe.make.some(Result.make.err("e"))); // Err("e")
+   * Maybe.transposeResult(Maybe.make.none());                     // Ok(None)
+   * ```
+   */
+  transposeResult: <E, A>(data: Maybe<Result<E, A>>) => Result<E, Maybe<A>>;
+};
+//#endregion
+//#region src/Core/Op.d.ts
+/**
+ * A reusable description of async work — decoupled from execution strategy and lifetime.
+ *
+ * Separate concerns:
+ * - **What** to do: encoded in the `Op` via `Op.create`
+ * - **How** to execute: chosen at `Op.interpret` time (restartable, exclusive, queue, etc.)
+ *
+ * An `Op` never runs on its own. It only executes when passed to `Op.interpret`, which
+ * attaches a concurrency strategy and returns a `Manager` that owns the execution.
+ *
+ * @example
+ * ```ts
+ * const fetchUser = Op.create(
+ *   (signal) => (id: string) =>
+ *     fetch(`/users/${id}`, { signal }).then(r => {
+ *       if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
+ *       return r.json() as Promise<User>;
+ *     }),
+ *   (e) => new ApiError(e),
+ * );
+ *
+ * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
+ * manager.subscribe(state => {
+ *   if (Op.is.pending(state)) showSpinner();
+ *   if (Op.is.ok(state))      render(state.value);
+ *   if (Op.is.err(state))     showError(state.error);
+ *   if (Op.is.nil(state))     resetUI();
+ * });
+ * 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 MaybeRetry<E, O> = O extends {
+  retry: RetryOptions<E>;
+} ? Op.Retrying<E> : never;
+type AllInterpretOptions<I, E> = ({
+  strategy: "once";
+  retry?: RetryOptions<E>;
+} & WithTimeout<E>) | ({
+  strategy: "restartable";
+  retry?: RetryOptions<E>;
+} & WithMinInterval & WithTimeout<E>) | ({
+  strategy: "exclusive";
+  retry?: RetryOptions<E>;
+} & WithCooldown & WithTimeout<E>) | ({
+  strategy: "queue";
+  retry?: RetryOptions<E>;
+  maxSize?: number;
+  overflow?: "drop" | "replace-last";
+  dedupe?: (a: I, b: I) => boolean;
+} & WithConcurrency & WithTimeout<E>) | ({
+  strategy: "buffered";
+  retry?: RetryOptions<E>;
+} & WithSize & WithTimeout<E>) | ({
+  strategy: "debounced";
+  retry?: RetryOptions<E>;
+  leading?: true;
+  maxWait?: Duration;
+} & WithDuration & WithTimeout<E>) | ({
+  strategy: "throttled";
+  retry?: RetryOptions<E>;
+  trailing?: true;
+} & WithDuration & WithTimeout<E>) | ({
+  strategy: "concurrent";
+  retry?: RetryOptions<E>;
+  overflow?: "queue" | "drop";
+} & WithN & WithTimeout<E>) | ({
+  strategy: "keyed";
+  perKey?: "exclusive" | "restartable";
+  key: (input: I) => unknown;
+} & WithTimeout<E>);
+type KeyType<I, O> = O extends {
+  key: (input: I) => infer K;
+} ? K : unknown;
+type InterpretResult<I, E, A, O> = [O] extends [{
+  strategy: "throttled";
+  trailing: true;
+}] ? Op.Manager<I, 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 [{
+  strategy: "debounced";
+}] ? Op.Manager<I, 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 [{
+  strategy: "concurrent";
+}] ? Op.Manager<I, 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 [{
+  strategy: "keyed";
+}] ? Op.KeyedManager<I, KeyType<I, O>, E, Op.KeyedExclusivePerKey<E, A>> : [O] extends [{
+  strategy: "once";
+}] ? Op.Manager<I, 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 [{
+  strategy: "exclusive";
+}] ? Op.Manager<I, 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 [{
+  strategy: "queue";
+  overflow: "replace-last";
+}] ? Op.Manager<I, 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 [{
+  strategy: "queue";
+  dedupe: (a: I, b: I) => boolean;
+}] ? Op.Manager<I, 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 [{
+  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>;
+declare const Op: {
+  make: {
+    /**
+     * Creates an Ok outcome with the given value.
+     *
+     * @example
+     * ```ts
+     * Op.make.ok(42); // { kind: "OpOk", value: 42 }
+     * ```
+     */
+    ok: <A>(value: A) => Op.Ok<A>;
+    /**
+     * Creates an Err outcome with the given error.
+     *
+     * @example
+     * ```ts
+     * Op.make.err("Something went wrong"); // { kind: "OpErr", error: "Something went wrong" }
+     * ```
+     */
+    err: <E>(error: E) => Op.Err<E>;
+    /**
+     * Creates a Nil outcome with the given cancellation/drop reason.
+     *
+     * @example
+     * ```ts
+     * Op.make.nil("aborted"); // { kind: "OpNil", reason: "aborted" }
+     * ```
+     */
+    nil: (reason: Op.NilReason) => Op.Nil;
+  };
+  is: {
+    /**
+     * Type guard that checks if an Op state is Idle.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.idle(manager.state)) {
+     *   console.log("Ready to execute");
+     * }
+     * ```
+     */
+    idle: <E, A>(state: Op.State<E, A>) => state is Op.Idle;
+    /**
+     * Type guard that checks if an Op state is Pending (actively executing).
+     *
+     * @example
+     * ```ts
+     * if (Op.is.pending(manager.state)) {
+     *   showSpinner();
+     * }
+     * ```
+     */
+    pending: <E, A>(state: Op.State<E, A>) => state is Op.Pending;
+    /**
+     * Type guard that checks if an Op state is Queued (waiting in a concurrency queue).
+     *
+     * @example
+     * ```ts
+     * if (Op.is.queued(manager.state)) {
+     *   console.log("Position in queue:", manager.state.position);
+     * }
+     * ```
+     */
+    queued: <E, A>(state: Op.State<E, A>) => state is Op.Queued;
+    /**
+     * Type guard that checks if an Op state is Retrying after a failure.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.retrying(manager.state)) {
+     *   console.log("Retry attempt:", manager.state.attempt);
+     * }
+     * ```
+     */
+    retrying: <E, A>(state: Op.State<E, A>) => state is Op.Retrying<E>;
+    /**
+     * Type guard that checks if an Op state or outcome is Ok.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.ok(outcome)) {
+     *   render(outcome.value);
+     * }
+     * ```
+     */
+    ok: <E, A>(state: Op.State<E, A>) => state is Op.Ok<A>;
+    /**
+     * Type guard that checks if an Op state or outcome is Err.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.err(outcome)) {
+     *   showError(outcome.error);
+     * }
+     * ```
+     */
+    err: <E, A>(state: Op.State<E, A>) => state is Op.Err<E>;
+    /**
+     * Type guard that checks if an Op state or outcome is Nil.
+     *
+     * @example
+     * ```ts
+     * if (Op.is.nil(outcome)) {
+     *   console.log("Skipped due to:", outcome.reason);
+     * }
+     * ```
+     */
+    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>;
+  match: <E, A, B>(cases: {
+    ok: (a: A) => B;
+    err: (e: E) => B;
+    nil: () => B;
+  }) => (outcome: Op.Outcome<E, A>) => B;
+  fold: <E, A, B>(onErr: (e: E) => B, onNil: () => B, onOk: (a: A) => B) => (outcome: Op.Outcome<E, A>) => B;
+  getOrElse: <E, A, B>(defaultValue: () => B) => (outcome: Op.Outcome<E, A>) => A | B;
+  map: <E, A, B>(f: (a: A) => B) => (outcome: Op.Outcome<E, A>) => Op.Outcome<E, B>;
+  mapError: <E, F, A>(f: (e: E) => F) => (outcome: Op.Outcome<E, A>) => Op.Outcome<F, A>;
+  chain: <E, A, B>(f: (a: A) => Op.Outcome<E, B>) => (outcome: Op.Outcome<E, A>) => Op.Outcome<E, B>;
+  tap: <E, A>(f: (a: A) => void) => (outcome: Op.Outcome<E, A>) => Op.Outcome<E, A>;
+  recover: <E, A, B>(f: (e: E) => Op.Outcome<E, B>) => (outcome: Op.Outcome<E, A>) => Op.Outcome<E, A | B>;
+  to: {
+    Result: <E, A>(onNil: () => E) => (outcome: Op.Outcome<E, A>) => Result<E, A>;
+    Maybe: <E, A>(outcome: Op.Outcome<E, A>) => Maybe<A>;
+  };
+  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;
+  interpret: typeof interpretFn;
+};
+declare namespace Op {
+  type Outcome<E, A> = Ok<A> | Err<E> | Nil;
+  type Ok<A> = WithKind<"OpOk"> & WithValue<A>;
+  type Err<E> = WithKind<"OpErr"> & WithError<E>;
+  type Nil = WithKind<"OpNil"> & {
+    readonly reason: NilReason;
+  };
+  type NilReason = "aborted" | "dropped" | "replaced" | "evicted";
+  type AbortedNil = Nil & {
+    readonly reason: "aborted";
+  };
+  type DroppedNil = Nil & {
+    readonly reason: "dropped";
+  };
+  type ReplacedNil = Nil & {
+    readonly reason: "replaced";
+  };
+  type EvictedNil = Nil & {
+    readonly reason: "evicted";
+  };
+  type State<E, A> = Idle | Pending | Queued | Retrying<E> | Outcome<E, A>;
+  type Idle = WithKind<"Idle">;
+  type Pending = WithKind<"Pending">;
+  type Queued = WithKind<"Queued"> & {
+    readonly position: number;
+  };
+  type Retrying<E> = WithKind<"Retrying"> & {
+    readonly attempt: number;
+    readonly lastError: E;
+    readonly nextRetryIn?: number;
+  };
+  type Manager<I, E, A, S extends State<E, A>> = {
+    readonly state: S;
+    run: (input: I) => Deferred<Exclude<S, Idle | Pending | Queued | Retrying<E>>>;
+    abort: () => void;
+    subscribe: (cb: (state: S) => void) => () => void;
+    reset: () => void;
+    poll: (input: I, options: {
+      interval: Duration;
+    }) => () => void;
+  };
+  type KeyedManager<I, K, E, PerKeyS> = {
+    readonly state: ReadonlyMap<K, PerKeyS>;
+    run: (input: I) => Deferred<Exclude<PerKeyS, Pending | Retrying<E>>>;
+    abort: (key?: K) => void;
+    subscribe: (cb: (state: ReadonlyMap<K, PerKeyS>) => void) => () => void;
+    reset: () => void;
+    poll: (input: I, options: {
+      interval: Duration;
+    }) => () => 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;
+  type RestartableState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
+  type RetryableRestartableState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
+  type ExclusiveState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type RetryableExclusiveState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type QueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
+  type RetryableQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
+  type QueueDropState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type RetryableQueueDropState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type QueueReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type RetryableQueueReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type QueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
+  type RetryableQueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
+  type BufferedState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type RetryableBufferedState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type DebouncedState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type RetryableDebouncedState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type ThrottledState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type RetryableThrottledState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type ThrottledTrailingState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type RetryableThrottledTrailingState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
+  type ConcurrentQueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
+  type RetryableConcurrentQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
+  type ConcurrentDropState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type RetryableConcurrentDropState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type KeyedExclusivePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
+  type KeyedRestartablePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
+  type RetryOptions<E> = RetryOptions<E>;
+  type TimeoutOptions<E> = TimeoutOptions<E>;
+}
+//#endregion
+//#region src/Core/Optional.d.ts
+/** Keys of T for which undefined is assignable (i.e. optional fields). */
+type OptionalKeys<T> = { [K in keyof T]-?: undefined extends T[K] ? K : never; }[keyof T];
+/**
+ * Optional<S, A> focuses on a value A inside a structure S that may or may
+ * not be present. Like a Lens, but get returns Maybe<A>.
+ *
+ * Compose with other Optionals via `andThen`, or with a Lens via `andThenLens`.
+ * Convert a Lens to an Optional with `Lens.toOptional`.
+ *
+ * @example
+ * ```ts
+ * type Profile = { username: string; bio?: string };
+ *
+ * const bioOpt = Optional.from.property<Profile>()("bio");
+ *
+ * pipe(profile, Optional.get(bioOpt));               // Some("hello") or None
+ * pipe(profile, Optional.set(bioOpt)("hello"));      // new Profile with bio set
+ * pipe(profile, Optional.modify(bioOpt)(s => s + "!")); // appends if present
+ * ```
+ */
+type Optional<S, A> = {
+  readonly get: (s: S) => Maybe<A>;
+  readonly set: (a: A) => (s: S) => S;
+};
+declare const Optional: {
+  from: {
+    /**
+     * Constructs an Optional from a getter (returning Maybe<A>) and a setter.
+     *
+     * @example
+     * ```ts
+     * const firstChar = Optional.from.accessors(
+     *   (s: string) => s.length > 0 ? Maybe.make.some(s[0]) : Maybe.make.none(),
+     *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
+     * );
+     * ```
+     */
+    accessors: <S, A>(get: (s: S) => Maybe<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
+    /**
+     * Creates an Optional that focuses on an optional property of an object.
+     * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
+     * Call with the structure type first, then the key.
+     *
+     * @example
+     * ```ts
+     * type Profile = { username: string; bio?: string };
+     * const bioOpt = Optional.from.property<Profile>()("bio");
+     * ```
+     */
+    property: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
+  };
+  /**
+   * Creates an Optional that focuses on an element at a given index in an array.
+   * Returns None when the index is out of bounds; set is a no-op when out of bounds.
+   *
+   * @example
+   * ```ts
+   * const firstItem = Optional.index<string>(0);
+   *
+   * pipe(["a", "b"], Optional.get(firstItem)); // Some("a")
+   * pipe([], Optional.get(firstItem));         // None
+   * ```
+   */
+  index: <A>(i: number) => Optional<A[], A>;
+  /**
+   * Reads the focused value from a structure, returning Maybe<A>.
+   *
+   * @example
+   * ```ts
+   * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
+   * ```
+   */
+  get: <S, A>(opt: Optional<S, A>) => (s: S) => Maybe<A>;
+  /**
+   * Replaces the focused value within a structure.
+   * For indexed focuses, this is a no-op when the index is out of bounds.
+   *
+   * @example
+   * ```ts
+   * pipe(profile, Optional.set(bioOpt)("hello"));
+   * ```
+   */
+  set: <S, A>(opt: Optional<S, A>) => (a: A) => (s: S) => S;
+  /**
+   * Applies a function to the focused value if it is present; returns the
+   * structure unchanged if the focus is absent.
+   *
+   * @example
+   * ```ts
+   * pipe(profile, Optional.modify(bioOpt)(s => s.toUpperCase()));
+   * ```
+   */
+  modify: <S, A>(opt: Optional<S, A>) => (f: (a: A) => A) => (s: S) => S;
+  /**
+   * Returns the focused value or a default when the focus is absent.
+   *
+   * @example
+   * ```ts
+   * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
+   * ```
+   */
+  getOrElse: <S, A>(opt: Optional<S, A>) => (defaultValue: () => A) => (s: S) => A;
+  /**
+   * Extracts a value from an Optional focus using handlers for the present
+   * and absent cases.
+   *
+   * @example
+   * ```ts
+   * pipe(profile, Optional.fold(bioOpt)(() => "no bio", (bio) => bio.toUpperCase()));
+   * ```
+   */
+  fold: <S, A>(opt: Optional<S, A>) => <B>(onNone: () => B, onSome: (a: A) => B) => (s: S) => B;
+  /**
+   * Pattern matches on an Optional focus using a named-case object.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   profile,
+   *   Optional.match(bioOpt)({ none: () => "no bio", some: (bio) => bio }),
+   * );
+   * ```
+   */
+  match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
+    none: () => B;
+    some: (a: A) => B;
+  }) => (s: S) => B;
+  /**
+   * Composes two Optionals: focuses through the outer, then through the inner.
+   * Returns None if either focus is absent.
+   *
+   * @example
+   * ```ts
+   * const deepOpt = pipe(
+   *   Optional.from.property<User>()("address"),
+   *   Optional.andThen(Optional.from.property<Address>()("landmark")),
+   * );
+   * ```
+   */
+  andThen: <A, B>(inner: Optional<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
+  /**
+   * Composes an Optional with a Lens, producing an Optional.
+   * The Lens focuses within the value found by the Optional.
+   *
+   * @example
+   * ```ts
+   * const cityOpt = pipe(
+   *   Optional.from.property<User>()("address"),
+   *   Optional.andThenLens(Lens.from.property<Address>()("city")),
+   * );
+   * ```
+   */
+  andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
+};
+//#endregion
+//#region src/Core/Ordering.d.ts
+/**
+ * A function that orders two values of type `A`. Returns a negative number when `a` comes before
+ * `b`, a positive number when `a` comes after `b`, and `0` when they are equal.
+ *
+ * Compatible with `Array.prototype.sort` and `Arr.sortWith`.
+ *
+ * @example
+ * ```ts
+ * type Employee = { name: string; salary: number };
+ *
+ * const byName   = pipe(Ordering.string, Ordering.by((e: Employee) => e.name));
+ * const bySalary = pipe(Ordering.number, Ordering.by((e: Employee) => e.salary));
+ *
+ * pipe(employees, Arr.sortWith(pipe(byName, Ordering.thenBy(bySalary))));
+ * ```
+ */
+type Ordering<A> = (a: A, b: A) => number;
+declare const Ordering: {
+  /**
+   * Alphabetical ordering for strings.
+   *
+   * @example
+   * ```ts
+   * Ordering.string("apple", "banana"); // negative
+   * ```
+   */
+  string: Ordering<string>;
+  /**
+   * Numeric ordering. Equivalent to `(a, b) => a - b`.
+   *
+   * @example
+   * ```ts
+   * pipe([3, 1, 2], Arr.sortWith(Ordering.number)); // [1, 2, 3]
+   * ```
+   */
+  number: Ordering<number>;
+  /**
+   * Ordering for `Date` values by numeric time value.
+   *
+   * @example
+   * ```ts
+   * pipe(dates, Arr.sortWith(Ordering.date)); // earliest first
+   * ```
+   */
+  date: Ordering<Date>;
+  /**
+   * Flips the direction of an ordering.
+   *
+   * @example
+   * ```ts
+   * pipe([3, 1, 2], Arr.sortWith(Ordering.reverse(Ordering.number))); // [3, 2, 1]
+   * ```
+   */
+  reverse: <A>(ord: Ordering<A>) => Ordering<A>;
+  /**
+   * Chains two orderings: the second is used only when the first returns `0`.
+   * Data-last: the first ordering is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const byDeptThenSalary = pipe(byDept, Ordering.thenBy(bySalary));
+   * ```
+   */
+  thenBy: <A>(ord2: Ordering<A>) => (ord1: Ordering<A>) => Ordering<A>;
+  /**
+   * Adapts an ordering for type `A` into an ordering for type `B` by extracting a field.
+   * Read as "ordering by this field": `pipe(Ordering.number, Ordering.by(p => p.price))`.
+   *
+   * @example
+   * ```ts
+   * type Product = { name: string; price: number };
+   * const byPrice = pipe(Ordering.number, Ordering.by((p: Product) => p.price));
+   * pipe(products, Arr.sortWith(byPrice));
+   * ```
+   */
+  by: <A, B>(f: (b: B) => A) => (ord: Ordering<A>) => Ordering<B>;
+  /**
+   * Combines a list of orderings into a single composite comparator.
+   * Evaluates each ordering in sequence until a non-zero comparison result is found.
+   *
+   * @example
+   * ```ts
+   * const byName = pipe(Ordering.string, Ordering.by((u: User) => u.name));
+   * const byAge  = pipe(Ordering.number, Ordering.by((u: User) => u.age));
+   * const sortUsers = Ordering.byFields([byName, byAge]);
+   * ```
+   */
+  byFields: <A>(orderings: ReadonlyArray<Ordering<A>>) => Ordering<A>;
+  /**
+   * Derives a lexicographical tuple ordering from positional `Ordering` comparators.
+   *
+   * @example
+   * ```ts
+   * const pairOrd = Ordering.tuple(Ordering.string, Ordering.number);
+   * pairOrd(["a", 1], ["a", 2]); // negative
+   * ```
+   */
+  tuple: <T extends readonly unknown[]>(...orderings: { [K in keyof T]: Ordering<T[K]>; }) => Ordering<T>;
+};
+//#endregion
+//#region src/Core/Pair.d.ts
+/**
+ * Pair<A, B> represents a pair of two values that are always both present.
+ * It is a typed alias for `readonly [A, B]`.
+ *
+ * Use Pair when two values always travel together through a pipeline and you
+ * want to transform either or both sides without destructuring.
+ *
+ * @example
+ * ```ts
+ * import { Pair } from "@nlozgachev/pipelined/core";
+ * import { pipe } from "@nlozgachev/pipelined/composition";
+ *
+ * const entry = Pair.from.pair("alice", 42);
+ *
+ * pipe(
+ *   entry,
+ *   Pair.mapFirst((name) => name.toUpperCase()),
+ *   Pair.mapSecond((score) => score * 2),
+ *   Pair.fold((name, score) => `${name}: ${score}`),
+ * ); // "ALICE: 84"
+ * ```
+ */
+type Pair<A, B> = readonly [A, B];
+declare const Pair: {
+  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.
+     *
+     * @example
+     * ```ts
+     * Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
+     * ```
+     */
+    array: <A, B>(arr: 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"
+   * ```
+   */
+  first: <A, B>(p: Pair<A, B>) => A;
+  /**
+   * Returns the second value from the pair.
+   *
+   * @example
+   * ```ts
+   * Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000
+   * ```
+   */
+  second: <A, B>(p: Pair<A, B>) => B;
+  /**
+   * Transforms the first value, leaving the second unchanged.
+   *
+   * @example
+   * ```ts
+   * pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
+   * ```
+   */
+  mapFirst: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
+  /**
+   * Transforms the second value, leaving the first unchanged.
+   *
+   * @example
+   * ```ts
+   * pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
+   * ```
+   */
+  mapSecond: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
+  /**
+   * Transforms both values independently in a single step.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Pair.from.pair("alice", 42),
+   *   Pair.mapBoth(
+   *     (name) => name.toUpperCase(),
+   *     (score) => score * 2,
+   *   ),
+   * ); // ["ALICE", 84]
+   * ```
+   */
+  mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (p: 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}`));
+   * // "Alice: 100"
+   * ```
+   */
+  fold: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
+  /**
+   * Swaps the two values: `[A, B]` becomes `[B, A]`.
+   *
+   * @example
+   * ```ts
+   * Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]
+   * ```
+   */
+  swap: <A, B>(p: 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]
+     * ```
+     */
+    Array: <A, B>(p: Pair<A, B>) => readonly (A | B)[];
+  };
+  /**
+   * Runs a side effect with both values without changing the pair.
+   * Useful for logging or debugging in the middle of a pipeline.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Pair.from.pair("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>;
+};
+//#endregion
+//#region src/Core/Predicate.d.ts
+/**
+ * A boolean-valued function over a type `A`.
+ *
+ * A `Predicate<A>` is the simpler sibling of `Refinement<A, B>`: it tests whether a
+ * value satisfies a condition at runtime but carries no compile-time narrowing guarantee.
+ * Use it when you need to combine, negate, or adapt boolean checks as first-class values
+ * and do not require the extra type information that a `Refinement` provides.
+ *
+ * Every `Refinement<A, B>` is a `Predicate<A>` — convert with `Predicate.from.Refinement`
+ * when you want to compose a narrowing check alongside plain predicates.
+ *
+ * @example
+ * ```ts
+ * const isAdult: Predicate<number> = n => n >= 18;
+ * const isRetired: Predicate<number> = n => n >= 65;
+ *
+ * const isWorkingAge: Predicate<number> = pipe(
+ *   isAdult,
+ *   Predicate.and(Predicate.not(isRetired))
+ * );
+ *
+ * isWorkingAge(30);  // true
+ * isWorkingAge(15);  // false
+ * isWorkingAge(70);  // false
+ * ```
+ */
+type Predicate<A> = (a: A) => boolean;
+declare const Predicate: {
+  /**
+   * Negates a predicate: the result passes exactly when the original fails.
+   *
+   * @example
+   * ```ts
+   * const isBlank: Predicate<string> = s => s.trim().length === 0;
+   * const isNotBlank = Predicate.not(isBlank);
+   *
+   * isNotBlank("hello");  // true
+   * isNotBlank("   ");    // false
+   * ```
+   */
+  not: <A>(p: Predicate<A>) => Predicate<A>;
+  /**
+   * Combines two predicates with logical AND: passes only when both hold.
+   *
+   * Data-last — the first predicate is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const isPositive: Predicate<number> = n => n > 0;
+   * const isEven: Predicate<number> = n => n % 2 === 0;
+   *
+   * const isPositiveEven: Predicate<number> = pipe(isPositive, Predicate.and(isEven));
+   *
+   * isPositiveEven(4);   // true
+   * isPositiveEven(3);   // false — positive but odd
+   * isPositiveEven(-2);  // false — even but not positive
+   * ```
+   */
+  and: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>;
+  /**
+   * Combines two predicates with logical OR: passes when either holds.
+   *
+   * Data-last — the first predicate is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const isChild: Predicate<number> = n => n < 13;
+   * const isSenior: Predicate<number> = n => n >= 65;
+   *
+   * const getsDiscount: Predicate<number> = pipe(isChild, Predicate.or(isSenior));
+   *
+   * getsDiscount(8);   // true
+   * getsDiscount(70);  // true
+   * getsDiscount(30);  // false
+   * ```
+   */
+  or: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>;
+  /**
+   * Adapts a `Predicate<A>` to work on a different input type `B` by applying `f`
+   * to extract the relevant `A` from a `B` before running the check.
+   *
+   * Data-last — the predicate is the data being piped; `f` is the extractor.
+   *
+   * @example
+   * ```ts
+   * type User = { name: string; age: number };
+   *
+   * const isAdult: Predicate<number> = n => n >= 18;
+   *
+   * // Lift isAdult to work on Users by extracting the age field
+   * const isAdultUser: Predicate<User> = pipe(
+   *   isAdult,
+   *   Predicate.using((u: User) => u.age)
+   * );
+   *
+   * isAdultUser({ name: "Alice", age: 30 });  // true
+   * isAdultUser({ name: "Bob",   age: 15 });  // false
+   * ```
+   */
+  using: <A, B>(f: (b: B) => A) => (p: Predicate<A>) => Predicate<B>;
+  /**
+   * Combines an array of predicates with AND: passes only when every predicate holds.
+   * Returns `true` for an empty array (vacuous truth).
+   *
+   * @example
+   * ```ts
+   * const checks: Predicate<string>[] = [
+   *   s => s.length > 0,
+   *   s => s.length <= 100,
+   *   s => !s.includes("<"),
+   * ];
+   *
+   * Predicate.all(checks)("hello");  // true
+   * Predicate.all(checks)("");       // false — too short
+   * Predicate.all(checks)("<b>");    // false — contains "<"
+   * Predicate.all([])("anything");   // true
+   * ```
+   */
+  all: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<A>;
+  /**
+   * Combines an array of predicates with OR: passes when at least one holds.
+   * Returns `false` for an empty array.
+   *
+   * @example
+   * ```ts
+   * const acceptedFormats: Predicate<string>[] = [
+   *   s => s.endsWith(".jpg"),
+   *   s => s.endsWith(".png"),
+   *   s => s.endsWith(".webp"),
+   * ];
+   *
+   * Predicate.any(acceptedFormats)("photo.jpg");   // true
+   * Predicate.any(acceptedFormats)("photo.gif");   // false
+   * Predicate.any([])("anything");                 // false
+   * ```
+   */
+  any: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<A>;
+  from: {
+    /**
+     * Converts a `Refinement<A, B>` into a `Predicate<A>`, discarding the compile-time
+     * narrowing. Use this when you want to combine a type guard with plain predicates
+     * using `and`, `or`, or `all`.
+     *
+     * This is a zero-cost runtime type cast.
+     *
+     * @example
+     * ```ts
+     * const isString: Refinement<unknown, string> =
+     *   Refinement.from.predicate(x => typeof x === "string");
+     *
+     * const isShortString: Predicate<unknown> = pipe(
+     *   Predicate.from.Refinement(isString),
+     *   Predicate.and(x => (x as string).length < 10)
+     * );
+     *
+     * isShortString("hi");            // true
+     * isShortString("a very long string that exceeds ten characters");  // false
+     * isShortString(42);              // false
+     * ```
+     */
+    Refinement: <A, B extends A>(r: Refinement<A, B>) => Predicate<A>;
+  };
+  /**
+   * Performs declarative conditional branching over `[predicate, handler]` pairs,
+   * returning the handler result of the first matching predicate or evaluating the fallback.
+   *
+   * @example
+   * ```ts
+   * const classifyNumber = Predicate.match(
+   *   [
+   *     [(n: number) => n < 0, () => "negative"],
+   *     [(n: number) => n === 0, () => "zero"],
+   *   ],
+   *   () => "positive",
+   * );
+   * classifyNumber(-5); // "negative"
+   * ```
+   */
+  match: <A, B>(branches: ReadonlyArray<readonly [Predicate<A>, (a: A) => B]>, fallback: (a: A) => B) => (a: A) => B;
+};
+//#endregion
+//#region src/Core/Reader.d.ts
+/**
+ * A computation that reads from a shared environment `R` and produces a value `A`.
+ * Use Reader to thread a dependency (config, logger, DB pool) through a pipeline
+ * without passing it explicitly to every function.
+ *
+ * @example
+ * ```ts
+ * type Config = { baseUrl: string; apiKey: string };
+ *
+ * const buildUrl = (path: string): Reader<Config, string> =>
+ *   (config) => `${config.baseUrl}${path}`;
+ *
+ * const withAuth = (url: string): Reader<Config, string> =>
+ *   (config) => `${url}?key=${config.apiKey}`;
+ *
+ * const fetchEndpoint = (path: string): Reader<Config, string> =>
+ *   pipe(
+ *     buildUrl(path),
+ *     Reader.chain(withAuth)
+ *   );
+ *
+ * // Inject the config once at the edge
+ * fetchEndpoint("/users")(appConfig); // "https://api.example.com/users?key=secret"
+ * ```
+ */
+type Reader<R, A> = (env: R) => A;
+declare const Reader: {
+  /**
+   * Lifts a pure value into a Reader. The environment is ignored.
+   *
+   * @example
+   * ```ts
+   * const always42: Reader<Config, number> = Reader.resolve(42);
+   * always42(anyConfig); // 42
+   * ```
+   */
+  resolve: <R, A>(value: A) => Reader<R, A>;
+  /**
+   * Returns the full environment as the result.
+   * The fundamental way to access the environment in a pipeline.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Reader.ask<Config>(),
+   *   Reader.map(config => config.baseUrl)
+   * )(appConfig); // "https://api.example.com"
+   * ```
+   */
+  ask: <R>() => Reader<R, R>;
+  /**
+   * Projects a value from the environment using a selector function.
+   * Equivalent to `pipe(Reader.ask(), Reader.map(f))` but more direct.
+   *
+   * @example
+   * ```ts
+   * const getBaseUrl: Reader<Config, string> = Reader.asks(c => c.baseUrl);
+   * getBaseUrl(appConfig); // "https://api.example.com"
+   * ```
+   */
+  asks: <R, A>(f: (env: R) => A) => Reader<R, A>;
+  /**
+   * Transforms the value produced by a Reader.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Reader.asks((c: Config) => c.baseUrl),
+   *   Reader.map(url => url.toUpperCase())
+   * )(appConfig); // "HTTPS://API.EXAMPLE.COM"
+   * ```
+   */
+  map: <R, A, B>(f: (a: A) => B) => (data: Reader<R, A>) => Reader<R, B>;
+  /**
+   * Sequences two Readers. Both see the same environment.
+   * The output of the first is passed to `f`, which returns the next Reader.
+   *
+   * @example
+   * ```ts
+   * const buildUrl = (path: string): Reader<Config, string> =>
+   *   Reader.asks(c => `${c.baseUrl}${path}`);
+   *
+   * const addAuth = (url: string): Reader<Config, string> =>
+   *   Reader.asks(c => `${url}?key=${c.apiKey}`);
+   *
+   * pipe(
+   *   buildUrl("/items"),
+   *   Reader.chain(addAuth)
+   * )(appConfig); // "https://api.example.com/items?key=secret"
+   * ```
+   */
+  chain: <R, A, B>(f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, B>;
+  /**
+   * Applies a function wrapped in a Reader to a value wrapped in a Reader.
+   * Both Readers see the same environment.
+   *
+   * @example
+   * ```ts
+   * 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))
+   * )(appConfig);
+   * ```
+   */
+  ap: <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.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   buildUrl("/users"),
+   *   Reader.tap(url => console.log("Requesting:", url)),
+   *   Reader.chain(addAuth)
+   * )(appConfig);
+   * ```
+   */
+  tap: <R, A>(f: (a: A) => void) => (data: Reader<R, A>) => Reader<R, A>;
+  /**
+   * Adapts a Reader to work with a different (typically wider) environment
+   * by transforming the environment before passing it to the Reader.
+   * This lets you compose Readers that expect different environments.
+   *
+   * @example
+   * ```ts
+   * type AppEnv = { db: DbPool; config: Config; logger: Logger };
+   *
+   * // buildUrl only needs Config
+   * const buildUrl: Reader<Config, string> = Reader.asks(c => c.baseUrl);
+   *
+   * // Zoom in from AppEnv to Config
+   * const buildUrlFromApp: Reader<AppEnv, string> =
+   *   pipe(buildUrl, Reader.local((env: AppEnv) => env.config));
+   *
+   * buildUrlFromApp(appEnv); // works with the full AppEnv
+   * ```
+   */
+  local: <R2, R>(f: (env: R2) => R) => <A>(data: Reader<R, A>) => Reader<R2, A>;
+  /**
+   * Runs a Reader by supplying the environment. Use this at the edge of your
+   * program where the environment is available.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   buildEndpoint("/users"),
+   *   Reader.run(appConfig)
+   * ); // "https://api.example.com/users?key=secret"
+   * ```
+   */
+  run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
+  /**
+   * Lifts a Reader value into an accumulator object.
+   *
+   * @example
+   * ```ts
+   * pipe(Reader.resolve(42), Reader.bindTo("value")); // Reader({ value: 42 })
+   * ```
+   */
+  bindTo: <K extends string>(key: K) => <R, A>(data: Reader<R, A>) => Reader<R, { [P in K]: A; }>;
+  /**
+   * Evaluates a new Reader using the current accumulator and attaches the output to a new key.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Reader.resolve({ a: 1 }),
+   *   Reader.bind("b", ({ a }) => Reader.resolve(a + 1))
+   * ); // Reader({ a: 1, b: 2 })
+   * ```
+   */
+  bind: <K extends string, R, A, B>(key: K, f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, A & { [P in K]: B; }>;
+};
+//#endregion
+//#region src/Core/Refinement.d.ts
+/**
+ * A function from `A` to `A is B` — a type predicate paired with a runtime check.
+ *
+ * A `Refinement<A, B>` proves at compile time that a value of type `A` is actually
+ * the narrower type `B extends A`, backed by a runtime boolean test. Use it to
+ * express domain invariants (non-empty strings, positive numbers, valid emails) as
+ * first-class, composable values rather than one-off type guards scattered across
+ * the codebase.
+ *
+ * @example
+ * ```ts
+ * type NonEmptyString = string & { readonly _tag: "NonEmptyString" };
+ *
+ * const isNonEmpty: Refinement<string, NonEmptyString> =
+ *   Refinement.from.predicate(s => s.length > 0);
+ *
+ * pipe(
+ *   "hello",
+ *   Refinement.to.Maybe(isNonEmpty)
+ * ); // Some("hello")
+ * ```
+ */
+type Refinement<A, B extends A> = (a: A) => a is B;
+declare const Refinement: {
+  from: {
+    /**
+     * Creates a `Refinement<A, B>` from a plain boolean predicate.
+     *
+     * This is an unsafe cast — the caller is responsible for ensuring that the
+     * predicate truly characterises values of type `B`. Use this only when
+     * bootstrapping a new refinement; prefer `compose`, `and`, or `or` to build
+     * derived refinements from existing ones.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "PositiveNumber" };
+     *
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.from.predicate(n => n > 0);
+     * ```
+     */
+    predicate: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
+  };
+  /**
+   * Chains two refinements: if `ab` narrows `A` to `B` and `bc` narrows `B` to `C`,
+   * the result narrows `A` directly to `C`.
+   *
+   * Data-last — the first refinement `ab` is the data being piped.
+   *
+   * @example
+   * ```ts
+   * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+   * type TrimmedString  = NonEmptyString & { readonly _tag: "Trimmed" };
+   *
+   * const isNonEmpty: Refinement<string, NonEmptyString> =
+   *   Refinement.from.predicate(s => s.length > 0);
+   * const isTrimmed: Refinement<NonEmptyString, TrimmedString> =
+   *   Refinement.from.predicate(s => s === s.trim());
+   *
+   * const isNonEmptyTrimmed: Refinement<string, TrimmedString> = pipe(
+   *   isNonEmpty,
+   *   Refinement.compose(isTrimmed)
+   * );
+   * ```
+   */
+  compose: <A, B extends A, C extends B>(bc: Refinement<B, C>) => (ab: Refinement<A, B>) => Refinement<A, C>;
+  /**
+   * Intersects two refinements: the result narrows `A` to `B & C`, passing only
+   * when both refinements hold simultaneously.
+   *
+   * Data-last — the first refinement is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const isString: Refinement<unknown, string> = Refinement.from.predicate(x => typeof x === "string");
+   * const isNonEmpty: Refinement<unknown, { length: number }> =
+   *   Refinement.from.predicate(x => (x as any).length > 0);
+   *
+   * const isNonEmptyString = pipe(isString, Refinement.and(isNonEmpty));
+   * isNonEmptyString("hi");  // true
+   * isNonEmptyString("");    // false
+   * ```
+   */
+  and: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>;
+  /**
+   * Unions two refinements: the result narrows `A` to `B | C`, passing when either
+   * refinement holds.
+   *
+   * Data-last — the first refinement is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const isString:  Refinement<unknown, string>  = Refinement.from.predicate(x => typeof x === "string");
+   * const isNumber:  Refinement<unknown, number>  = Refinement.from.predicate(x => typeof x === "number");
+   *
+   * const isStringOrNumber = pipe(isString, Refinement.or(isNumber));
+   * isStringOrNumber("hi"); // true
+   * isStringOrNumber(42);   // true
+   * isStringOrNumber(true); // false
+   * ```
+   */
+  or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
+  to: {
+    /**
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Maybe<B>`.
+     *
+     * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
+     * integrating runtime validation into a `Maybe`-based pipeline.
+     *
+     * @example
+     * ```ts
+     * type PositiveNumber = number & { readonly _tag: "Positive" };
+     * const isPositive: Refinement<number, PositiveNumber> =
+     *   Refinement.from.predicate(n => n > 0);
+     *
+     * pipe(-1, Refinement.to.Maybe(isPositive)); // None
+     * pipe(42, Refinement.to.Maybe(isPositive)); // Some(42)
+     * ```
+     */
+    Maybe: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Maybe<B>;
+    /**
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
+     *
+     * Returns `Ok(a)` when the refinement holds, `Err(onFail(a))` otherwise. Use
+     * this to surface validation failures as typed errors inside a `Result` pipeline.
+     *
+     * @example
+     * ```ts
+     * type NonEmptyString = string & { readonly _tag: "NonEmpty" };
+     * const isNonEmpty: Refinement<string, NonEmptyString> =
+     *   Refinement.from.predicate(s => s.length > 0);
+     *
+     * pipe("", Refinement.to.Result(isNonEmpty, () => "must not be empty")); // Err(...)
+     * pipe("hi", Refinement.to.Result(isNonEmpty, () => "must not be empty")); // Ok("hi")
+     * ```
+     */
+    Result: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+  };
+};
+//#endregion
+//#region src/Core/RemoteData.d.ts
+/**
+ * RemoteData represents the state of an async data fetch.
+ * It has four states: NotAsked, Loading, Failure, and Success.
+ *
+ * Use RemoteData to model data fetching states explicitly,
+ * replacing the common `{ data: T | null; loading: boolean; error: Error | null }` pattern.
+ *
+ * @example
+ * ```ts
+ * const renderUser = pipe(
+ *   userData,
+ *   RemoteData.match({
+ *     notAsked: () => "Click to load",
+ *     loading: () => "Loading...",
+ *     failure: e => `Error: ${e.message}`,
+ *     success: user => `Hello, ${user.name}!`
+ *   })
+ * );
+ * ```
+ */
+type RemoteData<E, A> = NotAsked | Loading | Failure<E> | Success<A>;
+type NotAsked = WithKind<"NotAsked">;
+type Loading = WithKind<"Loading">;
+type Failure<E> = WithKind<"Failure"> & WithError<E>;
+type Success<A> = WithKind<"Success"> & WithValue<A>;
+declare const RemoteData: {
+  make: {
+    /**
+     * Creates a NotAsked RemoteData.
+     *
+     * @example
+     * ```ts
+     * RemoteData.make.notAsked(); // NotAsked
+     * ```
+     */
+    notAsked: () => NotAsked;
+    /**
+     * Creates a Loading RemoteData.
+     *
+     * @example
+     * ```ts
+     * RemoteData.make.loading(); // Loading
+     * ```
+     */
+    loading: () => Loading;
+    /**
+     * Creates a Failure RemoteData with the given error.
+     *
+     * @example
+     * ```ts
+     * RemoteData.make.failure("Network error"); // Failure("Network error")
+     * ```
+     */
+    failure: <E>(error: E) => Failure<E>;
+    /**
+     * Creates a Success RemoteData with the given value.
+     *
+     * @example
+     * ```ts
+     * RemoteData.make.success(42); // Success(42)
+     * ```
+     */
+    success: <A>(value: A) => Success<A>;
+  };
+  is: {
+    /**
+     * Type guard that checks if a RemoteData is NotAsked.
+     *
+     * @example
+     * ```ts
+     * const data = RemoteData.make.notAsked();
+     * if (RemoteData.is.notAsked(data)) {
+     *   console.log("Data fetch not initiated");
+     * }
+     * ```
+     */
+    notAsked: <E, A>(data: RemoteData<E, A>) => data is NotAsked;
+    /**
+     * Type guard that checks if a RemoteData is Loading.
+     *
+     * @example
+     * ```ts
+     * const data = RemoteData.make.loading();
+     * if (RemoteData.is.loading(data)) {
+     *   console.log("Data is loading");
+     * }
+     * ```
+     */
+    loading: <E, A>(data: RemoteData<E, A>) => data is Loading;
+    /**
+     * Type guard that checks if a RemoteData is Failure.
+     *
+     * @example
+     * ```ts
+     * const data = RemoteData.make.failure("Failed");
+     * if (RemoteData.is.failure(data)) {
+     *   console.log(data.error); // "Failed"
+     * }
+     * ```
+     */
+    failure: <E, A>(data: RemoteData<E, A>) => data is Failure<E>;
+    /**
+     * Type guard that checks if a RemoteData is Success.
+     *
+     * @example
+     * ```ts
+     * const data = RemoteData.make.success(42);
+     * if (RemoteData.is.success(data)) {
+     *   console.log(data.value); // 42
+     * }
+     * ```
+     */
+    success: <E, A>(data: RemoteData<E, A>) => data is Success<A>;
+  };
+  /**
+   * Transforms the success value inside a RemoteData.
+   *
+   * @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>;
+  /**
+   * Transforms the error value inside a RemoteData.
+   *
+   * @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>;
+  /**
+   * Chains RemoteData computations. If the input is Success, passes the value to f.
+   * Otherwise, propagates the current state.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   RemoteData.make.success(5),
+   *   RemoteData.chain(n => n > 0 ? RemoteData.make.success(n) : RemoteData.make.failure("negative"))
+   * );
+   * ```
+   */
+  chain: <E2, A, B>(f: (a: A) => RemoteData<E2, B>) => <E1 = never>(data: RemoteData<E1, A>) => RemoteData<E1 | E2, B>;
+  /**
+   * Applies a function wrapped in a RemoteData to a value wrapped in a RemoteData.
+   *
+   * @example
+   * ```ts
+   * 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))
+   * ); // Success(8)
+   * ```
+   */
+  ap: <E, A>(arg: RemoteData<E, A>) => <B>(data: RemoteData<E, (a: A) => B>) => RemoteData<E, B>;
+  /**
+   * Extracts the value from a RemoteData by providing handlers for all four cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   userData,
+   *   RemoteData.fold(
+   *     e => `Error: ${e}`,
+   *     () => "Not asked",
+   *     () => "Loading...",
+   *     value => `Got: ${value}`
+   *   )
+   * );
+   * ```
+   */
+  fold: <E, A, B>(onFailure: (e: E) => B, onNotAsked: () => B, onLoading: () => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
+  /**
+   * Pattern matches on a RemoteData, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   userData,
+   *   RemoteData.match({
+   *     notAsked: () => "Click to load",
+   *     loading: () => "Loading...",
+   *     failure: e => `Error: ${e}`,
+   *     success: user => `Hello, ${user.name}!`
+   *   })
+   * );
+   * ```
+   */
+  match: <E, A, B>(cases: {
+    notAsked: () => B;
+    loading: () => B;
+    failure: (e: E) => B;
+    success: (a: A) => B;
+  }) => (data: 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`.
+   *
+   * @example
+   * ```ts
+   * pipe(RemoteData.make.success(5), RemoteData.getOrElse(() => 0)); // 5
+   * pipe(RemoteData.make.loading(), RemoteData.getOrElse(() => 0)); // 0
+   * 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;
+  /**
+   * Executes a side effect on the success value without changing the RemoteData.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   RemoteData.make.success(5),
+   *   RemoteData.tap(n => console.log("Value:", n)),
+   *   RemoteData.map(n => n * 2)
+   * );
+   * ```
+   */
+  tap: <E, A>(f: (a: A) => void) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+  /**
+   * Executes a side effect on the failure error without changing the RemoteData.
+   * Useful for logging errors.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   RemoteData.make.failure("not found"),
+   *   RemoteData.tapError(e => console.error("fetch failed:", e)),
+   *   RemoteData.map(render)
+   * );
+   * ```
+   */
+  tapError: <E, A>(f: (e: E) => void) => (data: 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>`.
+   */
+  recover: <E, B>(fallback: (e: E) => RemoteData<E, B>) => <A>(data: RemoteData<E, A>) => RemoteData<E, 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>;
+    /**
+     * Converts a RemoteData to a Result.
+     * Success becomes Ok, Failure becomes Err.
+     * NotAsked and Loading become Err with the provided fallback error.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   RemoteData.make.success(42),
+     *   RemoteData.to.Result(() => "not loaded")
+     * ); // Ok(42)
+     * ```
+     */
+    Result: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
+  };
+  from: {
+    /**
+     * Converts a Result to a RemoteData.
+     * Ok becomes Success, Err becomes Failure.
+     *
+     * @example
+     * ```ts
+     * const result = await Task.Result.tryCatch(() => loadUser(), { onError: String })();
+     * setState(RemoteData.from.Result(result)); // Success(user) or Failure(msg)
+     * ```
+     */
+    Result: <E, A>(data: Result<E, A>) => RemoteData<E, A>;
+    /**
+     * Converts a Maybe to a RemoteData.
+     * Some becomes Success, None becomes Failure using the onNone error producer.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.make.some(user), RemoteData.from.Maybe(() => "not found")); // Success(user)
+     * pipe(Maybe.make.none(), RemoteData.from.Maybe(() => "not found"));     // Failure("not found")
+     * ```
+     */
+    Maybe: <E>(onNone: () => E) => <A>(data: Maybe<A>) => RemoteData<E, A>;
+  };
+  /**
+   * Filters a `Success` value. When the predicate passes, the value is kept. When it fails,
+   * `Success` becomes `Failure` using the error produced by `onFalse`. All other states pass through unchanged.
+   *
+   * @example
+   * ```ts
+   * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.make.success(9.99));
+   * // Success(9.99)
+   * RemoteData.filter(n => n > 0, n => `${n} is not a valid price`)(RemoteData.make.success(-1));
+   * // Failure("-1 is not a valid price")
+   * 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>;
+};
+//#endregion
+//#region src/Core/Resource.d.ts
+/**
+ * A Resource pairs an async acquisition step with a guaranteed cleanup step.
+ *
+ * Use it whenever something must be explicitly closed, released, or torn down
+ * after you are done with it — database connections, file handles, locks,
+ * temporary directories, or any object with a lifecycle.
+ *
+ * The key guarantee: `release` always runs after `Resource.use`, even when
+ * the work function returns an error. If `acquire` itself fails, `release` is
+ * skipped — there is nothing to clean up.
+ *
+ * Build a Resource with `Resource.from.handlers` or `Resource.from.Task`, then run it
+ * with `Resource.use`.
+ *
+ * @example
+ * ```ts
+ * const dbResource = Resource.from.handlers(
+ *   Task.Result.tryCatch(() => openConnection(config), { onError: (e) => new DbError(e) }),
+ *   (conn) => Task.tryCatch(() => conn.close(), { onError: () => {} })
+ * );
+ *
+ * const result = await pipe(
+ *   dbResource,
+ *   Resource.use((conn) => queryUser(conn, userId))
+ * )();
+ * // conn.close() is called whether queryUser succeeds or fails
+ * ```
+ */
+type Resource<E, A> = {
+  readonly acquire: Task.Result<E, A>;
+  readonly release: (a: A) => Task<void>;
+};
+declare const Resource: {
+  from: {
+    /**
+     * Creates a Resource from an acquire operation that may fail and a release function.
+     *
+     * @example
+     * ```ts
+     * const fileResource = Resource.from.handlers(
+     *   Task.Result.tryCatch(() => fs.promises.open("data.csv", "r"), { onError: toFileError }),
+     *   (handle) => Task.tryCatch(() => handle.close(), { onError: () => {} })
+     * );
+     * ```
+     */
+    handlers: <E, A>(acquire: Task.Result<E, A>, release: (a: A) => Task<void>) => Resource<E, A>;
+    /**
+     * Creates a Resource from an acquire operation that cannot fail.
+     * Use this when opening the resource is guaranteed to succeed, such as
+     * in-memory locks, counters, or timers.
+     *
+     * @example
+     * ```ts
+     * const timerResource = Resource.from.Task<never, Timer>(
+     *   Task.tryCatch(() => Promise.resolve(startTimer()), { onError: () => defaultTimer }),
+     *   (timer) => Task.tryCatch(() => Promise.resolve(timer.stop()), { onError: () => {} })
+     * );
+     * ```
+     */
+    Task: <E, A>(acquire: Task<A>, release: (a: A) => Task<void>) => Resource<E, A>;
+  };
+  /**
+   * Acquires the resource, runs `f` with it, then releases it.
+   *
+   * Release always runs, even when `f` returns an error.
+   * If acquire fails, `f` and release are both skipped and the error is returned.
+   *
+   * @example
+   * ```ts
+   * const rows = await pipe(
+   *   dbResource,
+   *   Resource.use((conn) => runQuery(conn, "SELECT * FROM users"))
+   * )();
+   * // conn is closed whether the query succeeds or fails
+   * ```
+   */
+  use: <E, A, B>(f: (a: A) => Task.Result<E, B>) => (resource: Resource<E, A>) => Task.Result<E, B>;
+  /**
+   * Acquires two resources in sequence and presents them as a tuple.
+   * Resources are released in reverse order: the second is released before the first.
+   *
+   * If the second resource fails to acquire, the first is released immediately
+   * before returning the error.
+   *
+   * @example
+   * ```ts
+   * const combined = Resource.combine(dbResource, cacheResource);
+   *
+   * const result = await pipe(
+   *   combined,
+   *   Resource.use(([conn, cache]) => lookupWithFallback(conn, cache, userId))
+   * )();
+   * ```
+   */
+  combine: <E, A, B>(resourceA: Resource<E, A>, resourceB: Resource<E, B>) => Resource<E, readonly [A, B]>;
+};
+//#endregion
+//#region src/Core/Result.d.ts
+/**
+ * Result represents a value that can be one of two types: a success (Ok) or a failure (Err).
+ * Use Result when an operation can fail with a meaningful error value.
+ *
+ * @example
+ * ```ts
+ * const divide = (a: number, b: number): Result<string, number> =>
+ *   b === 0 ? Result.make.err("Division by zero") : Result.make.ok(a / b);
+ *
+ * pipe(
+ *   divide(10, 2),
+ *   Result.map(n => n * 2),
+ *   Result.getOrElse(() => 0)
+ * ); // 10
+ * ```
+ */
+type Result<E, A> = Ok$1<A> | Err$1<E>;
+type Ok$1<A> = WithKind<"Ok"> & WithValue<A>;
+type Err$1<E> = WithKind<"Err"> & WithError<E>;
+declare const Result: {
+  make: {
+    /**
+     * Creates a successful Result with the given value.
+     *
+     * @example
+     * ```ts
+     * Result.make.ok(42); // Ok(42)
+     * ```
+     */
+    ok: <A>(value: A) => Ok$1<A>;
+    /**
+     * Creates a failed Result with the given error.
+     *
+     * @example
+     * ```ts
+     * Result.make.err("Error message"); // Err("Error message")
+     * ```
+     */
+    err: <E>(e: E) => Err$1<E>;
+  };
+  is: {
+    /**
+     * Type guard that checks if a Result is Ok.
+     *
+     * @example
+     * ```ts
+     * const res = Result.make.ok(42);
+     * if (Result.is.ok(res)) {
+     *   console.log(res.value); // 42
+     * }
+     * ```
+     */
+    ok: <E, A>(data: Result<E, A>) => data is Ok$1<A>;
+    /**
+     * Type guard that checks if a Result is Err.
+     *
+     * @example
+     * ```ts
+     * const res = Result.make.err("failed");
+     * if (Result.is.err(res)) {
+     *   console.log(res.error); // "failed"
+     * }
+     * ```
+     */
+    err: <E, A>(data: Result<E, A>) => data is Err$1<E>;
+  };
+  /**
+   * Creates a Result from a synchronous thunk that may throw.
+   * Catches any errors and transforms them using the `onError` function.
+   *
+   * @example
+   * ```ts
+   * const result = Result.tryCatch(
+   *   () => JSON.parse(rawString),
+   *   { onError: (e) => `Parse error: ${e}` }
+   * );
+   * ```
+   */
+  tryCatch: <E, A>(f: () => A, options: {
+    onError: (e: unknown) => E;
+  }) => Result<E, A>;
+  /**
+   * Transforms the success value inside a Result.
+   *
+   * @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>;
+  /**
+   * Transforms the error value inside a Result.
+   *
+   * @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>;
+  /**
+   * Chains Result computations. If the first is Ok, passes the value to f.
+   * If the first is Err, propagates the error.
+   *
+   * @example
+   * ```ts
+   * const validatePositive = (n: number): Result<string, number> =>
+   *   n > 0 ? Result.make.ok(n) : Result.make.err("Must be positive");
+   *
+   * pipe(Result.make.ok(5), Result.chain(validatePositive)); // Ok(5)
+   * 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>;
+  /**
+   * Extracts the value from a Result by providing handlers for both cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(5),
+   *   Result.fold(
+   *     e => `Error: ${e}`,
+   *     n => `Value: ${n}`
+   *   )
+   * ); // "Value: 5"
+   * ```
+   */
+  fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B) => (data: Result<E, A>) => B;
+  /**
+   * Pattern matches on a Result, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   result,
+   *   Result.match({
+   *     ok: value => `Got ${value}`,
+   *     err: error => `Failed: ${error}`
+   *   })
+   * );
+   * ```
+   */
+  match: <E, A, B>(cases: {
+    ok: (a: A) => B;
+    err: (e: E) => B;
+  }) => (data: 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`.
+   *
+   * @example
+   * ```ts
+   * pipe(Result.make.ok(5), Result.getOrElse(() => 0)); // 5
+   * pipe(Result.make.err("error"), Result.getOrElse(() => 0)); // 0
+   * 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;
+  /**
+   * Executes a side effect on the success value without changing the Result.
+   * Useful for logging or debugging.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(5),
+   *   Result.tap(n => console.log("Value:", n)),
+   *   Result.map(n => n * 2)
+   * );
+   * ```
+   */
+  tap: <E, A>(f: (a: A) => void) => (data: Result<E, A>) => Result<E, A>;
+  /**
+   * Executes a side effect on the error value without changing the Result.
+   * Useful for logging or reporting errors.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.err("not found"),
+   *   Result.tapError(e => console.error("validation failed:", e)),
+   *   Result.chain(save),
+   * )
+   * ```
+   */
+  tapError: <E, A>(f: (e: E) => void) => (data: Result<E, A>) => Result<E, A>;
+  from: {
+    /**
+     * Creates a Result from a predicate applied to a value.
+     * Returns Ok if the predicate passes, Err from onFalse otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(5, Result.from.Predicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
+     * pipe(-1, Result.from.Predicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
+     * 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>;
+    /**
+     * Creates a Result from a nullable value.
+     * Returns Ok if the value is not null or undefined, error from onNull otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Result.from.nullable(() => "is null")); // Err("is null")
+     * pipe(42, Result.from.nullable(() => "is null"));   // Ok(42)
+     * ```
+     */
+    nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Result<E, A>;
+    /**
+     * Creates a Result from a Maybe.
+     * Some becomes Ok, None becomes error from onNone.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.make.none(), Result.from.Maybe(() => "is none")); // Err("is none")
+     * pipe(Maybe.make.some(42), Result.from.Maybe(() => "is none")); // Ok(42)
+     * ```
+     */
+    Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
+    /**
+     * Converts a `Validation` to a `Result`, combining accumulated errors using `combineErrors`.
+     * `Passed(a)` becomes `Ok(a)`; `Failed(errors)` becomes `Err(combineErrors(errors))`.
+     *
+     * @example
+     * ```ts
+     * 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>;
+  };
+  /**
+   * 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>`.
+   */
+  recover: <E, B>(fallback: (e: E) => Result<E, B>) => <A>(data: Result<E, A>) => Result<E, 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>`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.err(new Error("not found")),
+   *   Result.recoverUnless(e => e.message === "fatal", () => Result.make.ok(0))
+   * ); // Ok(0)
+   * ```
+   */
+  recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => <A>(data: Result<E, A>) => Result<E, A | B>;
+  to: {
+    /**
+     * Converts a Result to a Maybe.
+     * Ok becomes Some, Err becomes None (the error is discarded).
+     *
+     * @example
+     * ```ts
+     * Result.to.Maybe(Result.make.ok(42)); // Some(42)
+     * Result.to.Maybe(Result.make.err("oops")); // None
+     * ```
+     */
+    Maybe: <E, A>(data: Result<E, A>) => Maybe<A>;
+    /**
+     * Converts a `Result` to a `Validation`. `Ok(a)` becomes `Passed(a)`; `Err(e)` becomes `Failed([e])`.
+     *
+     * @example
+     * ```ts
+     * Result.to.Validation(Result.make.ok(42));     // Passed(42)
+     * Result.to.Validation(Result.make.err("bad")); // Failed(["bad"])
+     * ```
+     */
+    Validation: <E, A>(data: Result<E, A>) => Validation<E, A>;
+  };
+  /**
+   * Swaps the outer `Result` and inner `Maybe` context.
+   * `Ok(Some(a))` becomes `Some(Ok(a))`, `Ok(None)` becomes `None`, and `Err(e)` becomes `Some(Err(e))`.
+   *
+   * @example
+   * ```ts
+   * Result.transposeMaybe(Result.make.ok(Maybe.make.some(42))); // Some(Ok(42))
+   * Result.transposeMaybe(Result.make.ok(Maybe.make.none()));   // None
+   * Result.transposeMaybe(Result.make.err("error"));           // Some(Err("error"))
+   * ```
+   */
+  transposeMaybe: <E, A>(data: Result<E, Maybe<A>>) => Maybe<Result<E, A>>;
+  /**
+   * Applies a function wrapped in a Result to a value wrapped in a Result.
+   *
+   * @example
+   * ```ts
+   * 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))
+   * ); // Ok(8)
+   * ```
+   */
+  ap: <E, A>(arg: Result<E, A>) => <B>(data: Result<E, (a: A) => B>) => Result<E, B>;
+  /**
+   * Converts a Result value into an object containing a single property.
+   * Initiates the pipeline accumulator record.
+   *
+   * @example
+   * ```ts
+   * 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; }>;
+  /**
+   * Evaluates a new Result using the current accumulator and attaches the output to a new key.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok({ a: 1 }),
+   *   Result.bind("b", ({ a }) => Result.make.ok(a + 1))
+   * ); // 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; }>;
+  /**
+   * Combines a record of Results into a single Result of a record.
+   * Evaluates fields in key order and short-circuits on the first failure.
+   *
+   * @example
+   * ```ts
+   * Result.struct({
+   *   name: Result.make.ok("Alice"),
+   *   age: Result.make.ok(30)
+   * }); // Ok({ name: "Alice", age: 30 })
+   * ```
+   */
+  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.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(15),
+   *   Result.ensure((n) => n >= 18, (n) => `Age ${n} is below 18`)
+   * ); // 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>;
+  /**
+   * Transforms both branches of a Result simultaneously.
+   * Applies `onErr` to `Err` values and `onOk` to `Ok` values.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Result.make.ok(5),
+   *   Result.bimap(
+   *     (e) => `Error: ${e}`,
+   *     (n) => n * 2
+   *   )
+   * ); // Ok(10)
+   * ```
+   */
+  bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (data: Result<E1, A>) => Result<E2, B>;
+};
+//#endregion
+//#region src/Core/State.d.ts
+/**
+ * A synchronous computation that threads a piece of mutable state `S` through
+ * a pipeline without exposing mutation at call sites.
+ *
+ * At runtime a `State<S, A>` is just a function from an initial state to a pair
+ * `[value, nextState]`. Nothing runs until you supply the initial state with
+ * `State.run`, `State.evaluate`, or `State.execute`.
+ *
+ * @example
+ * ```ts
+ * type Counter = number;
+ *
+ * const increment: State<Counter, undefined> = State.modify(n => n + 1);
+ * const getCount:  State<Counter, Counter>   = State.get();
+ *
+ * const program = pipe(
+ *   increment,
+ *   State.chain(() => increment),
+ *   State.chain(() => getCount),
+ * );
+ *
+ * State.run(0)(program); // [2, 2]  — value is 2, final state is 2
+ * ```
+ */
+type State$1<S, A> = (s: S) => readonly [A, S];
+declare const State$1: {
+  /**
+   * Lifts a pure value into a State computation. The state passes through unchanged.
+   *
+   * @example
+   * ```ts
+   * State.run(10)(State.resolve(42)); // [42, 10] — value 42, state unchanged
+   * ```
+   */
+  resolve: <S, A>(value: A) => State$1<S, A>;
+  /**
+   * Produces the current state as the value, without modifying it.
+   *
+   * @example
+   * ```ts
+   * const readStack: State<string[], string[]> = State.get();
+   * State.run(["a", "b"])(readStack); // [["a", "b"], ["a", "b"]]
+   * ```
+   */
+  get: <S>() => State$1<S, S>;
+  /**
+   * Reads a projection of the state without modifying it.
+   * Equivalent to `pipe(State.get(), State.map(f))` but more direct.
+   *
+   * @example
+   * ```ts
+   * type AppState = { count: number; label: string };
+   * const readCount: State<AppState, number> = State.gets(s => s.count);
+   * State.run({ count: 5, label: "x" })(readCount); // [5, { count: 5, label: "x" }]
+   * ```
+   */
+  gets: <S, A>(f: (s: S) => A) => State$1<S, A>;
+  /**
+   * Replaces the current state with a new value. Produces no meaningful value.
+   *
+   * @example
+   * ```ts
+   * const reset: State<number, undefined> = State.put(0);
+   * State.run(99)(reset); // [undefined, 0]
+   * ```
+   */
+  put: <S>(newState: S) => State$1<S, undefined>;
+  /**
+   * Applies a function to the current state to produce the next state.
+   * Produces no meaningful value.
+   *
+   * @example
+   * ```ts
+   * const push = (item: string): State<string[], undefined> =>
+   *   State.modify(stack => [...stack, item]);
+   *
+   * State.run(["a"])(push("b")); // [undefined, ["a", "b"]]
+   * ```
+   */
+  modify: <S>(f: (s: S) => S) => State$1<S, undefined>;
+  /**
+   * Transforms the value produced by a State computation.
+   * The state transformation is unchanged.
+   *
+   * @example
+   * ```ts
+   * const readLength: State<string[], number> = pipe(
+   *   State.get<string[]>(),
+   *   State.map(stack => stack.length),
+   * );
+   *
+   * State.run(["a", "b", "c"])(readLength); // [3, ["a", "b", "c"]]
+   * ```
+   */
+  map: <S, A, B>(f: (a: A) => B) => (st: State$1<S, A>) => State$1<S, B>;
+  /**
+   * Sequences two State computations. The state output of the first is passed
+   * as the state input to the second.
+   *
+   * Data-last — the first computation is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const push = (item: string): State<string[], undefined> =>
+   *   State.modify(stack => [...stack, item]);
+   *
+   * const program = pipe(
+   *   push("a"),
+   *   State.chain(() => push("b")),
+   *   State.chain(() => State.get<string[]>()),
+   * );
+   *
+   * State.evaluate([])(program); // ["a", "b"]
+   * ```
+   */
+  chain: <S, A, B>(f: (a: A) => State$1<S, B>) => (st: State$1<S, A>) => State$1<S, B>;
+  /**
+   * Applies a function wrapped in a State to a value wrapped in a State.
+   * The function computation runs first; its output state is the input to the
+   * argument computation.
+   *
+   * @example
+   * ```ts
+   * 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.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>;
+  /**
+   * Runs a side effect on the produced value without changing the State computation.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   State.get<number>(),
+   *   State.tap(n => console.log("current:", n)),
+   *   State.chain(() => State.modify(n => n + 1)),
+   * );
+   * ```
+   */
+  tap: <S, A>(f: (a: A) => void) => (st: State$1<S, A>) => State$1<S, A>;
+  /**
+   * Runs a State computation with an initial state, returning both the
+   * produced value and the final state as a pair.
+   *
+   * Data-last — the computation is the data being piped.
+   *
+   * @example
+   * ```ts
+   * const program = pipe(
+   *   State.modify<number>(n => n + 1),
+   *   State.chain(() => State.get<number>()),
+   * );
+   *
+   * State.run(0)(program); // [1, 1]
+   * ```
+   */
+  run: <S>(initialState: S) => <A>(st: State$1<S, A>) => readonly [A, S];
+  /**
+   * Runs a State computation with an initial state, returning only the
+   * produced value (discarding the final state).
+   *
+   * @example
+   * ```ts
+   * State.evaluate([])(pipe(
+   *   State.modify<string[]>(s => [...s, "x"]),
+   *   State.chain(() => State.get<string[]>()),
+   * )); // ["x"]
+   * ```
+   */
+  evaluate: <S>(initialState: S) => <A>(st: State$1<S, A>) => A;
+  /**
+   * Runs a State computation with an initial state, returning only the
+   * final state (discarding the produced value).
+   *
+   * @example
+   * ```ts
+   * State.execute(0)(pipe(
+   *   State.modify<number>(n => n + 10),
+   *   State.chain(() => State.modify<number>(n => n * 2)),
+   * )); // 20
+   * ```
+   */
+  execute: <S>(initialState: S) => <A>(st: State$1<S, A>) => S;
+  /**
+   * Lifts a State value into an accumulator object.
+   *
+   * @example
+   * ```ts
+   * pipe(State.resolve(42), State.bindTo("value")); // State({ value: 42 })
+   * ```
+   */
+  bindTo: <K extends string>(key: K) => <S, A>(data: State$1<S, A>) => State$1<S, { [P in K]: A; }>;
+  /**
+   * Evaluates a new State using the current accumulator and attaches the output to a new key.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   State.resolve({ a: 1 }),
+   *   State.bind("b", ({ a }) => State.resolve(a + 1))
+   * ); // State({ a: 1, b: 2 })
+   * ```
+   */
+  bind: <K extends string, S, A, B>(key: K, f: (a: A) => State$1<S, B>) => (data: State$1<S, A>) => State$1<S, A & { [P in K]: B; }>;
+  /**
+   * Focuses a State computation on a sub-state using a Lens.
+   *
+   * @example
+   * ```ts
+   * type AppState = { count: number; name: string };
+   * const countLens = Lens.from.property<AppState>()("count");
+   * const increment = State.modify((c: number) => c + 1);
+   * const focusedProgram = pipe(increment, State.focus(countLens));
+   * ```
+   */
+  focus: <S, A>(lens: Lens<S, A>) => <B>(stateOp: State$1<A, B>) => State$1<S, B>;
+};
+//#endregion
+//#region src/Core/Validation.d.ts
+/**
+ * Validation represents a value that is either passed with a success value,
+ * or failed with accumulated errors.
+ * Unlike Result, Validation can accumulate multiple errors instead of short-circuiting.
+ *
+ * Use Validation when you need to collect all errors (e.g., form validation).
+ * Use Result when you want to fail fast on the first error.
+ *
+ * @example
+ * ```ts
+ * const validateName = (name: string): Validation<string, string> =>
+ *   name.length > 0 ? Validation.make.passed(name) : Validation.make.failed("Name is required");
+ *
+ * const validateAge = (age: number): Validation<string, number> =>
+ *   age >= 0 ? Validation.make.passed(age) : Validation.make.failed("Age must be positive");
+ *
+ * // Accumulates all errors using ap
+ * pipe(
+ *   Validation.make.passed((name: string) => (age: number) => ({ name, age })),
+ *   Validation.ap(validateName("")),
+ *   Validation.ap(validateAge(-1))
+ * );
+ * // Failed(["Name is required", "Age must be positive"])
+ * ```
+ */
+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 const Validation: {
+  make: {
+    /**
+     * Wraps a value in a passed Validation.
+     *
+     * @example
+     * ```ts
+     * Validation.make.passed(42); // Passed(42)
+     * ```
+     */
+    passed: <E, A>(value: A) => Validation<E, A>;
+    /**
+     * Creates a failed Validation from a single error.
+     *
+     * @example
+     * ```ts
+     * Validation.make.failed("Invalid input");
+     * ```
+     */
+    failed: <E>(error: E) => Failed<E>;
+    /**
+     * Creates a failed Validation from multiple errors.
+     *
+     * @example
+     * ```ts
+     * Validation.make.failedAll(["Invalid input"]);
+     * ```
+     */
+    failedAll: <E>(errors: NonEmptyArr<E>) => Failed<E>;
+  };
+  is: {
+    /**
+     * Type guard that checks if a Validation is passed.
+     *
+     * @example
+     * ```ts
+     * const v = Validation.make.passed(42);
+     * if (Validation.is.passed(v)) {
+     *   console.log(v.value); // 42
+     * }
+     * ```
+     */
+    passed: <E, A>(data: Validation<E, A>) => data is Passed<A>;
+    /**
+     * Type guard that checks if a Validation is failed.
+     *
+     * @example
+     * ```ts
+     * const v = Validation.make.failed("invalid");
+     * if (Validation.is.failed(v)) {
+     *   console.log(v.errors); // ["invalid"]
+     * }
+     * ```
+     */
+    failed: <E, A>(data: Validation<E, A>) => data is Failed<E>;
+  };
+  /**
+   * Creates a Validation from a synchronous thunk that may throw.
+   * Catches any errors and transforms them using the `onError` function into a Failed validation.
+   *
+   * @example
+   * ```ts
+   * const result = Validation.tryCatch(
+   *   () => JSON.parse(rawString),
+   *   { onError: (e) => `Parse error: ${e}` }
+   * );
+   * ```
+   */
+  tryCatch: <E, A>(f: () => A, options: {
+    onError: (e: unknown) => E;
+  }) => Validation<E, A>;
+  from: {
+    /**
+     * Creates a Validation from a predicate applied to a value.
+     * Returns Passed if the predicate passes, Failed from `onFalse` otherwise.
+     *
+     * @example
+     * ```ts
+     * const validateName = Validation.from.Predicate(
+     *   (s: string) => s.length > 0,
+     *   () => "Name is required"
+     * );
+     *
+     * validateName("Alice"); // Passed("Alice")
+     * validateName("");      // Failed(["Name is required"])
+     * ```
+     */
+    Predicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: 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.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Validation.from.nullable(() => "is null")); // Failed(["is null"])
+     * pipe(42, Validation.from.nullable(() => "is null"));   // Passed(42)
+     * ```
+     */
+    nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Validation<E, A>;
+    /**
+     * Creates a Validation from a Maybe.
+     * If the Maybe is None, returns Failed with the error from onNone.
+     * Otherwise, returns Passed.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.make.none(), Validation.from.Maybe(() => "is none")); // Failed(["is none"])
+     * pipe(Maybe.make.some(42), Validation.from.Maybe(() => "is none")); // Passed(42)
+     * ```
+     */
+    Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Validation<E, A>;
+    /**
+     * Converts a `Result` to a `Validation`. `Ok` becomes `Passed`; `Err(e)` becomes `Failed([e])`.
+     *
+     * Useful when bridging from error-short-circuiting `Result` pipelines into
+     * error-accumulating `Validation` pipelines.
+     *
+     * @example
+     * ```ts
+     * Validation.from.Result(Result.make.ok(42));       // Passed(42)
+     * Validation.from.Result(Result.make.err("bad"));   // Failed(["bad"])
+     * ```
+     */
+    Result: <E, A>(data: Result<E, A>) => Validation<E, A>;
+  };
+  /**
+   * Transforms the success value inside a Validation.
+   *
+   * @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>;
+  /**
+   * Transforms the error list inside a Validation.
+   *
+   * @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>;
+  /**
+   * Applies a function wrapped in a Validation to a value wrapped in a Validation.
+   * Accumulates errors from both sides.
+   *
+   * @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))
+   * ); // Passed(8)
+   *
+   * pipe(
+   *   Validation.make.passed(add),
+   *   Validation.ap(Validation.make.failed<string>("bad a")),
+   *   Validation.ap(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));
+   * ```
+   */
+  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>;
+  /**
+   * Extracts the value from a Validation by providing handlers for both cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.passed(42),
+   *   Validation.fold(
+   *     errors => `Errors: ${errors.join(", ")}`,
+   *     value => `Value: ${value}`
+   *   )
+   * );
+   * ```
+   */
+  fold: <E, A, B>(onFailed: (errors: NonEmptyArr<E>) => B, onPassed: (a: A) => B) => (data: Validation<E, A>) => B;
+  /**
+   * Pattern matches on a Validation, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   validation,
+   *   Validation.match({
+   *     passed: value => `Got ${value}`,
+   *     failed: errors => `Failed: ${errors.join(", ")}`
+   *   })
+   * );
+   * ```
+   */
+  match: <E, A, B>(cases: {
+    passed: (a: A) => B;
+    failed: (errors: NonEmptyArr<E>) => B;
+  }) => (data: 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`.
+   *
+   * @example
+   * ```ts
+   * pipe(Validation.make.passed(5), Validation.getOrElse(() => 0)); // 5
+   * pipe(Validation.make.failed("oops"), Validation.getOrElse(() => 0)); // 0
+   * 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;
+  /**
+   * Executes a side effect on the success value without changing the Validation.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.passed(5),
+   *   Validation.tap(n => console.log("Value:", n)),
+   *   Validation.map(n => n * 2)
+   * );
+   * ```
+   */
+  tap: <E, A>(f: (a: A) => void) => (data: 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.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.failed("Name required"),
+   *   Validation.tapError(errors => console.error("validation failed:", errors)),
+   *   Validation.map(toUser)
+   * );
+   * ```
+   */
+  tapError: <E, A>(f: (errors: NonEmptyArr<E>) => void) => (data: 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>`.
+   */
+  recover: <E, B>(fallback: (errors: NonEmptyArr<E>) => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, 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>`.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Validation.make.failed("field-error"),
+   *   Validation.recoverUnless(e => e === "fatal", () => Validation.make.passed(0))
+   * ); // Passed(0)
+   * ```
+   */
+  recoverUnless: <E, B>(isBlocked: (e: E) => boolean, fallback: () => Validation<E, B>) => <A>(data: Validation<E, A>) => Validation<E, A | B>;
+  to: {
+    /**
+     * Converts a Validation to a Result.
+     * Passed becomes Ok.
+     * Direct call converts Failed to Err with accumulated error list `NonEmptyArr<E>`.
+     * Curried call converts Failed to Err with combined error `E2` via `combineErrors`.
+     *
+     * @example
+     * ```ts
+     * Validation.to.Result(Validation.make.passed(42));        // Ok(42)
+     * Validation.to.Result(Validation.make.failed("oops"));  // Err(["oops"])
+     * pipe(Validation.make.failed("oops"), Validation.to.Result(errors => errors.join(", "))); // Err("oops")
+     * ```
+     */
+    Result: typeof toResult;
+    /**
+     * Converts a Validation to a Maybe. `Passed` becomes `Some`; `Failed` becomes `None`
+     * (errors are discarded).
+     *
+     * @example
+     * ```ts
+     * Validation.to.Maybe(Validation.make.passed(42));       // Some(42)
+     * Validation.to.Maybe(Validation.make.failed("bad"));  // None
+     * ```
+     */
+    Maybe: <E, A>(data: 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.
+   *
+   * @example
+   * ```ts
+   * Validation.product(
+   *   Validation.make.passed("alice"),
+   *   Validation.make.passed(30)
+   * ); // Passed(["alice", 30])
+   *
+   * Validation.product(
+   *   Validation.make.failed("Name required"),
+   *   Validation.make.failed("Age must be >= 0")
+   * ); // Failed(["Name required", "Age must be >= 0"])
+   * ```
+   */
+  product: <E, A, B>(first: Validation<E, A>, second: Validation<E, B>) => Validation<E, readonly [A, B]>;
+  /**
+   * Combines a non-empty list of Validation instances, accumulating all errors.
+   * If all are Passed, returns Passed with all values collected into an array.
+   * If any are Failed, returns Failed with all accumulated errors.
+   *
+   * @example
+   * ```ts
+   * Validation.productAll([
+   *   validateName(name),
+   *   validateEmail(email),
+   *   validateAge(age)
+   * ]);
+   * // Passed([name, email, age]) or Failed([...all errors])
+   * ```
+   */
+  productAll: <E, A>(data: 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.
+   *
+   * @example
+   * ```ts
+   * Validation.struct({
+   *   name: Validation.make.passed("Alice"),
+   *   age: Validation.make.passed(30)
+   * }); // Passed({ name: "Alice", age: 30 })
+   *
+   * Validation.struct({
+   *   name: Validation.make.failed("Name required"),
+   *   age: Validation.make.failed("Age must be >= 0")
+   * }); // Failed(["Name required", "Age must be >= 0"])
+   * ```
+   */
+  struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Validation<E, R[K]>; }) => Validation<E, R>;
+};
+//#endregion
+//#region src/Core/Task.d.ts
+/**
+ * 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.resolve(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();
+ * ```
+ */
+type Task<A> = (signal?: AbortSignal) => Deferred<A>;
+declare const Task: {
+  /**
+   * Creates a Task that immediately resolves to the given value.
+   *
+   * @example
+   * ```ts
+   * const task = Task.resolve(42);
+   * const value = await task(); // 42
+   * ```
+   */
+  resolve: <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.
+     *
+     * @example
+     * ```ts
+     * const t = Task.from.sync(() => Date.now()); // Date.now() not called yet
+     * const ts = await t(); // called here, every time
+     * ```
+     */
+    sync: <A>(f: () => A) => Task<A>;
+  };
+  /**
+   * Wraps a Promise-returning thunk that may throw or reject,
+   * trapping errors with a fallback function and returning a guaranteed `Task<A>`.
+   *
+   * @example
+   * ```ts
+   * const loadConfig = Task.tryCatch(
+   *   () => configStore.get("default"),
+   *   { onError: () => DEFAULT_CONFIG }
+   * );
+   * ```
+   */
+  tryCatch: <A>(f: (signal?: AbortSignal) => globalThis.Promise<A>, options: {
+    onError: (error: unknown) => A;
+  }) => Task<A>;
+  /**
+   * Transforms the value inside a Task.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Task.resolve(5),
+   *   Task.map(n => n * 2)
+   * )(); // Deferred<10>
+   * ```
+   */
+  map: <A, B>(f: (a: A) => B) => (data: Task<A>) => Task<B>;
+  /**
+   * Chains Task computations. Passes the resolved value of the first Task to f.
+   *
+   * @example
+   * ```ts
+   * const readUserId: Task<string> = Task.resolve(session.userId);
+   * const loadPrefs = (id: string): Task<Preferences> =>
+   *   Task.resolve(prefsCache.get(id));
+   *
+   * pipe(
+   *   readUserId,
+   *   Task.chain(loadPrefs)
+   * )(); // Deferred<Preferences>
+   * ```
+   */
+  chain: <A, B>(f: (a: A) => Task<B>) => (data: Task<A>) => Task<B>;
+  /**
+   * Applies a function wrapped in a Task to a value wrapped in a Task.
+   * Both Tasks run 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))
+   * )(); // Deferred<8>
+   * ```
+   */
+  ap: <A>(arg: Task<A>) => <B>(data: Task<(a: A) => B>) => Task<B>;
+  /**
+   * Executes a side effect on the value without changing the Task.
+   * Useful for logging or debugging.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   loadConfig,
+   *   Task.tap(cfg => console.log("Config:", cfg)),
+   *   Task.map(buildReport)
+   * );
+   * ```
+   */
+  tap: <A>(f: (a: A) => void) => (data: 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.
+   *
+   * @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, 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.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Task.resolve(42),
+   *   Task.delay(Duration.seconds(1))
+   * )(); // Resolves after 1 second
+   * ```
+   */
+  delay: (duration: Duration) => <A>(data: 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.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   pollSensor,
+   *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
+   * )(); // Task<Reading[]> — 5 readings, one per second
+   * ```
+   */
+  repeat: (options: {
+    times: number;
+    delay?: Duration;
+  }) => <A>(task: Task<A>) => Task<readonly A[]>;
+  /**
+   * 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.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   checkStatus,
+   *   Task.poll({ until: (s) => s === "ready", delay: Duration.milliseconds(500) })
+   * )(); // polls every 500ms until status is "ready"
+   * ```
+   */
+  poll: <A>(options: {
+    until: (a: A) => boolean;
+    delay?: Duration;
+    attempts?: number;
+  }) => (task: Task<A>) => Task<A>;
+  /**
+   * Resolves with the value of the first Task to complete. All Tasks start
+   * immediately. When one resolves, the other tasks are cancelled (aborted)
+   * downstream.
+   *
+   * @example
+   * ```ts
+   * const fast = Task.resolve("fast");
+   * const slow = Task.delay(Duration.milliseconds(200))(Task.resolve("slow"));
+   *
+   * await Task.race([fast, slow])(); // "fast"
+   * ```
+   */
+  race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
+  /**
+   * Runs an array of Tasks concurrently and collects their results in an array.
+   * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
+   *
+   * @example
+   * ```ts
+   * Task.sequence([loadConfig, detectLocale, loadTheme])();
+   * // Deferred<[Config, string, Theme]>
+   * ```
+   */
+  sequence: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
+  /**
+   * Runs an array of Tasks one at a time in order, collecting all results.
+   * Each Task starts only after the previous one resolves.
+   *
+   * @example
+   * ```ts
+   * let log: number[] = [];
+   * const makeTask = (n: number) => Task.resolve(n);
+   *
+   * await Task.sequential([makeTask(1), makeTask(2), makeTask(3)])();
+   * // log = [1, 2, 3] — tasks ran in order
+   * ```
+   */
+  sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
+  /**
+   * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
+   * Task does not complete within the given duration. The inner Task receives an
+   * `AbortSignal` that fires when the deadline passes, so asynchronous operations
+   * that accept a signal are cancelled rather than left dangling.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   heavyComputation,
+   *   Task.timeout({ duration: Duration.seconds(5), onTimeout: () => "timed out" }),
+   *   Task.Result.chain(processResult)
+   * );
+   * ```
+   */
+  timeout: <E>(options: {
+    duration: Duration;
+    onTimeout: () => E;
+  }) => <A>(task: Task<A>) => Task<Result<E, A>>;
+  /**
+   * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
+   * current in-flight call immediately. Unlike a one-shot abort, calling `task()`
+   * again after `abort()` starts a fresh call with a new signal.
+   *
+   * Each invocation of `task()` automatically cancels the previous in-flight call,
+   * making it safe to call repeatedly (e.g. on user input) without leaking promises.
+   *
+   * If an outer signal is also present (passed at the call site), aborting it
+   * propagates into the internal controller.
+   *
+   * @example
+   * ```ts
+   * const { task: poll, abort } = Task.abortable(
+   *   (signal) => waitForEvent(bus, "ready", { signal }),
+   * );
+   *
+   * onUnmount(abort);
+   * await poll();
+   * ```
+   */
+  abortable: <A>(factory: (signal: AbortSignal) => Thenable<A>) => {
+    task: Task<A>;
+    abort: () => void;
+  };
+  /**
+   * Executes a task with an optional signal. Use as a terminal step in a `pipe` chain.
+   *
+   * @example
+   * ```ts
+   * const name = await pipe(
+   *     loadConfig,
+   *     Task.map(config => config.name),
+   *     Task.run(),
+   * );
+   * ```
+   */
+  run: (signal?: AbortSignal) => <A>(task: Task<A>) => Deferred<A>;
+  /**
+   * Converts a Task value into an object containing a single property.
+   * Initiates the pipeline accumulator record.
+   *
+   * @example
+   * ```ts
+   * pipe(Task.resolve(42), Task.bindTo("value")); // Task({ value: 42 })
+   * ```
+   */
+  bindTo: <K extends string>(key: K) => <A>(data: 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({ 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; }>;
+  /**
+   * 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.
+   *
+   * @example
+   * ```ts
+   * const loadToken = Task.memoize(loadAuthToken);
+   * const token1 = await loadToken(); // loads token
+   * const token2 = await loadToken(); // returns cached token immediately
+   * ```
+   */
+  memoize: <A>(task: Task<A>) => Task<A>;
+  /**
+   * Monitors progress of a Task by calling `onProgress(0)` before execution and `onProgress(1)` upon completion.
+   *
+   * @example
+   * ```ts
+   * const taskWithProgress = pipe(
+   *   readTask,
+   *   Task.withProgress((ratio) => console.log(`Progress: ${ratio * 100}%`))
+   * );
+   * ```
+   */
+  withProgress: <A>(onProgress: (ratio: number) => void) => (task: Task<A>) => Task<A>;
+  /**
+   * Attaches a read-only `.label` property to a Task, preserving the literal string generic type for IDE tooltips.
+   *
+   * @example
+   * ```ts
+   * const labeledTask = pipe(readTask, Task.withLabel("readUser"));
+   * console.log(labeledTask.label); // "readUser"
+   * ```
+   */
+  withLabel: <L extends string>(label: L) => <A>(task: Task<A>) => Task.LabeledTask<L, A>;
+  Maybe: {
+    make: {
+      some: <A>(value: A) => Task.Maybe<A>;
+      none: <A = never>() => Task.Maybe<A>;
+    };
+    from: {
+      Maybe: <A>(option: 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>;
+    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>;
+    to: {
+      Result: <E>(onNone: () => E) => <A>(data: 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>;
+    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>;
+  };
+  Result: {
+    make: {
+      ok: <E = never, A = unknown>(value: A) => Task.Result<E, A>;
+      err: <E, A = never>(error: E) => Task.Result<E, A>;
+    };
+    from: {
+      nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Task.Result<E, A>;
+      Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Task.Result<E, A>;
+      Result: <E, A>(result: Result<E, A>) => Task.Result<E, A>;
+    };
+    to: {
+      Maybe: <E, A>(data: Task.Result<E, A>) => Task.Maybe<A>;
+    };
+    tryCatch: <E, A>(f: (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>;
+    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>;
+    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; }>;
+    struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Result<E, R[K]>; }) => Task.Result<E, R>;
+    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: (a: A) => boolean, onFail: (a: A) => E2) => <E1 = never>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A>;
+    bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (task: Task.Result<E1, A>) => Task.Result<E2, B>;
+  };
+  Validation: {
+    make: {
+      passed: <E = never, A = unknown>(value: A) => Task.Validation<E, A>;
+      failed: <E, A = never>(error: E) => Task.Validation<E, A>;
+      failedAll: <E, A = never>(errors: NonEmptyArr<E>) => Task.Validation<E, A>;
+    };
+    from: {
+      Validation: <E, A>(validation: Validation<E, A>) => Task.Validation<E, A>;
+      nullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Task.Validation<E, A>;
+      Maybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Task.Validation<E, A>;
+      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>;
+    };
+    tryCatch: <E, A>(f: (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>;
+    match: <E, A, B>(cases: {
+      passed: (a: 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>;
+    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>;
+    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>;
+  };
+};
+type _CoreMaybe<A> = Maybe<A>;
+type _CoreResult<E, A> = Result<E, A>;
+type _CoreValidation<E, A> = Validation<E, A>;
+declare namespace Task {
+  type LabeledTask<L extends string, A> = Task<A> & {
+    readonly label: L;
+  };
+  type Maybe<A> = Task<_CoreMaybe<A>>;
+  type Result<E, A> = Task<_CoreResult<E, A>>;
+  type Validation<E, A> = Task<_CoreValidation<E, A>>;
+}
+//#endregion
+//#region src/Core/These.d.ts
+/**
+ * These<A, B> is an inclusive-OR type: it holds a first value (A), a second
+ * value (B), or both simultaneously. Neither side carries a success/failure
+ * connotation — it is a neutral pair where any combination is valid.
+ *
+ * - First(a)     — only a first value
+ * - Second(b)    — only a second value
+ * - Both(a, b)   — first and second values simultaneously
+ *
+ * A common use: lenient parsers or processors that carry a diagnostic note
+ * alongside a result, without losing either piece of information.
+ *
+ * @example
+ * ```ts
+ * const parse = (s: string): These<number, string> => {
+ *   const trimmed = s.trim();
+ *   const n = parseFloat(trimmed);
+ *   if (isNaN(n)) return These.make.second("Not a number");
+ *   if (s !== trimmed) return These.make.both(n, "Leading/trailing whitespace trimmed");
+ *   return These.make.first(n);
+ * };
+ * ```
+ */
+type These<A, B> = TheseFirst<A> | TheseSecond<B> | TheseBoth<A, B>;
+type TheseFirst<T> = WithKind<"First"> & WithFirst<T>;
+type TheseSecond<T> = WithKind<"Second"> & WithSecond<T>;
+type TheseBoth<First, Second> = WithKind<"Both"> & WithFirst<First> & WithSecond<Second>;
+declare const These: {
+  make: {
+    /**
+     * Creates a These holding only a first value.
+     *
+     * @example
+     * ```ts
+     * These.make.first(42); // { kind: "First", first: 42 }
+     * ```
+     */
+    first: <A>(value: A) => TheseFirst<A>;
+    /**
+     * Creates a These holding only a second value.
+     *
+     * @example
+     * ```ts
+     * These.make.second("warning"); // { kind: "Second", second: "warning" }
+     * ```
+     */
+    second: <B>(value: B) => TheseSecond<B>;
+    /**
+     * Creates a These holding both a first and a second value simultaneously.
+     *
+     * @example
+     * ```ts
+     * 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>;
+  };
+  is: {
+    /**
+     * Type guard — checks if a These holds only a first value.
+     *
+     * @example
+     * ```ts
+     * const val = These.make.first(42);
+     * if (These.is.first(val)) {
+     *   console.log(val.first); // 42
+     * }
+     * ```
+     */
+    first: <A, B>(data: These<A, B>) => data is TheseFirst<A>;
+    /**
+     * Type guard — checks if a These holds only a second value.
+     *
+     * @example
+     * ```ts
+     * const val = These.make.second("warning");
+     * if (These.is.second(val)) {
+     *   console.log(val.second); // "warning"
+     * }
+     * ```
+     */
+    second: <A, B>(data: These<A, B>) => data is TheseSecond<B>;
+    /**
+     * Type guard — checks if a These holds both values simultaneously.
+     *
+     * @example
+     * ```ts
+     * const val = These.make.both(42, "warning");
+     * if (These.is.both(val)) {
+     *   console.log(val.first, val.second); // 42 "warning"
+     * }
+     * ```
+     */
+    both: <A, B>(data: These<A, B>) => data is TheseBoth<A, B>;
+  };
+  /**
+   * Returns true if the These contains a first value (First or Both).
+   *
+   * @example
+   * ```ts
+   * These.hasFirst(These.make.first(42));       // true
+   * These.hasFirst(These.make.both(42, "warn"));// true
+   * These.hasFirst(These.make.second("warn"));  // false
+   * ```
+   */
+  hasFirst: <A, B>(data: These<A, B>) => data is TheseFirst<A> | TheseBoth<A, B>;
+  /**
+   * Returns true if the These contains a second value (Second or Both).
+   *
+   * @example
+   * ```ts
+   * These.hasSecond(These.make.second("warn"));  // true
+   * These.hasSecond(These.make.both(42, "warn"));// true
+   * These.hasSecond(These.make.first(42));       // false
+   * ```
+   */
+  hasSecond: <A, B>(data: These<A, B>) => data is TheseSecond<B> | TheseBoth<A, B>;
+  /**
+   * Transforms the first value, leaving the second unchanged.
+   *
+   * @example
+   * ```ts
+   * pipe(These.make.first(5), These.mapFirst(n => n * 2));           // First(10)
+   * pipe(These.make.both(5, "warn"), These.mapFirst(n => n * 2));    // Both(10, "warn")
+   * 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>;
+  /**
+   * Transforms the second value, leaving the first unchanged.
+   *
+   * @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>;
+  /**
+   * Transforms both the first and second values independently.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   These.make.both(5, "warn"),
+   *   These.mapBoth(n => n * 2, e => e.toUpperCase())
+   * ); // Both(10, "WARN")
+   * ```
+   */
+  mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (data: 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.
+   *
+   * @example
+   * ```ts
+   * const double = (n: number): These<number, string> => These.make.first(n * 2);
+   *
+   * pipe(These.make.first(5), These.chainFirst(double));            // First(10)
+   * pipe(These.make.both(5, "warn"), These.chainFirst(double));     // First(10)
+   * 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>;
+  /**
+   * Chains These computations by passing the second value to f.
+   * First propagates unchanged; Second and Both apply f to the second value.
+   *
+   * @example
+   * ```ts
+   * const shout = (s: string): These<number, string> => These.make.second(s.toUpperCase());
+   *
+   * pipe(These.make.second("warn"), These.chainSecond(shout));      // Second("WARN")
+   * pipe(These.make.both(5, "warn"), These.chainSecond(shout));     // Second("WARN")
+   * 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>;
+  /**
+   * Extracts a value from a These by providing handlers for all three cases.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   these,
+   *   These.fold(
+   *     a => `First: ${a}`,
+   *     b => `Second: ${b}`,
+   *     (a, b) => `Both: ${a} / ${b}`
+   *   )
+   * );
+   * ```
+   */
+  fold: <A, B, C>(onFirst: (a: A) => C, onSecond: (b: B) => C, onBoth: (a: A, b: B) => C) => (data: These<A, B>) => C;
+  /**
+   * Pattern matches on a These, returning the result of the matching case.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   these,
+   *   These.match({
+   *     first: a => `First: ${a}`,
+   *     second: b => `Second: ${b}`,
+   *     both: (a, b) => `Both: ${a} / ${b}`
+   *   })
+   * );
+   * ```
+   */
+  match: <A, B, C>(cases: {
+    first: (a: A) => C;
+    second: (b: B) => C;
+    both: (a: A, b: B) => C;
+  }) => (data: 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`.
+   *
+   * @example
+   * ```ts
+   * pipe(These.make.first(5), These.getFirstOrElse(() => 0));            // 5
+   * pipe(These.make.both(5, "warn"), These.getFirstOrElse(() => 0));     // 5
+   * pipe(These.make.second("warn"), These.getFirstOrElse(() => 0));      // 0
+   * 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;
+  /**
+   * 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`.
+   *
+   * @example
+   * ```ts
+   * pipe(These.make.second("warn"), These.getSecondOrElse(() => "none")); // "warn"
+   * pipe(These.make.both(5, "warn"), These.getSecondOrElse(() => "none")); // "warn"
+   * pipe(These.make.first(5), These.getSecondOrElse(() => "none"));       // "none"
+   * 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;
+  /**
+   * Runs a side effect on the first value without changing the These.
+   * Useful for logging or debugging.
+   *
+   * @example
+   * ```ts
+   * 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>;
+  /**
+   * Swaps the roles of first and second values.
+   * - First(a)    → Second(a)
+   * - Second(b)   → First(b)
+   * - Both(a, b)  → Both(b, a)
+   *
+   * @example
+   * ```ts
+   * These.swap(These.make.first(5));            // Second(5)
+   * These.swap(These.make.second("warn"));      // First("warn")
+   * These.swap(These.make.both(5, "warn"));     // Both("warn", 5)
+   * ```
+   */
+  swap: <A, B>(data: These<A, B>) => These<B, A>;
+};
+//#endregion
+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 };