@nlozgachev/pipelined 0.62.0 → 0.64.0

package/dist/core.d.cts

@@ -1,7 +1,7 @@
-import { M as Maybe, R as Result, T as Task } from './Validation-DC3uUizM.cjs';
-export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Validation-DC3uUizM.cjs';
-import { o as WithValue, i as WithLog, D as Deferred, h as WithKind, e as WithError, R as RetryOptions, b as TimeoutOptions, n as WithTimeout, j as WithMinInterval, c as WithCooldown, W as WithConcurrency, m as WithSize, d as WithDuration, k as WithN, g as WithFirst, l as WithSecond } from './InternalTypes-DuK_XpTi.cjs';
-import { D as Duration } from './Duration-B8joKzro.cjs';
+import { M as Maybe, R as Result, T as Task } from './Task-C_goFYQ1.cjs';
+export { E as Equality, a as Err, F as Failed, N as None, O as Ok, b as Ordering, P as Passed, S as Some, V as Validation } from './Task-C_goFYQ1.cjs';
+import { o as WithValue, i as WithLog, D as Deferred, R as RetryOptions, n as WithTimeout, j as WithMinInterval, c as WithCooldown, W as WithConcurrency, m as WithSize, d as WithDuration, k as WithN, h as WithKind, e as WithError, b as TimeoutOptions, g as WithFirst, l as WithSecond } from './InternalTypes-GFn4RTwD.cjs';
+import { D as Duration } from './Duration-DeyxG6VQ.cjs';
 import './types.cjs';
 
 /**
@@ -19,7 +19,7 @@ type Combinable<A> = {
     readonly empty: A;
     readonly combine: (b: A) => (a: A) => A;
 };
-declare namespace Combinable {
+declare const Combinable: {
     /**
      * Combines strings by concatenation. Empty string is the neutral element.
      *
@@ -28,7 +28,7 @@ declare namespace Combinable {
      * pipe(["a", "b", "c"], Combinable.fold(Combinable.string)); // "abc"
      * ```
      */
-    const string: Combinable<string>;
+    string: Combinable<string>;
     /**
      * Combines numbers by addition. `0` is the neutral element.
      *
@@ -37,7 +37,7 @@ declare namespace Combinable {
      * pipe([1, 2, 3], Combinable.fold(Combinable.sum)); // 6
      * ```
      */
-    const sum: Combinable<number>;
+    sum: Combinable<number>;
     /**
      * Combines numbers by multiplication. `1` is the neutral element.
      *
@@ -46,7 +46,7 @@ declare namespace Combinable {
      * pipe([2, 3, 4], Combinable.fold(Combinable.product)); // 24
      * ```
      */
-    const product: Combinable<number>;
+    product: Combinable<number>;
     /**
      * Combines booleans with logical AND. `true` is the neutral element.
      *
@@ -55,7 +55,7 @@ declare namespace Combinable {
      * pipe([true, true, false], Combinable.fold(Combinable.all)); // false
      * ```
      */
-    const all: Combinable<boolean>;
+    all: Combinable<boolean>;
     /**
      * Combines booleans with logical OR. `false` is the neutral element.
      *
@@ -64,7 +64,7 @@ declare namespace Combinable {
      * pipe([false, false, true], Combinable.fold(Combinable.any)); // true
      * ```
      */
-    const any: Combinable<boolean>;
+    any: Combinable<boolean>;
     /**
      * Combines arrays by concatenation. Empty array is the neutral element.
      *
@@ -73,7 +73,7 @@ declare namespace Combinable {
      * pipe([[1, 2], [3], [4, 5]], Combinable.fold(Combinable.array<number>())); // [1, 2, 3, 4, 5]
      * ```
      */
-    const array: <A>() => Combinable<readonly A[]>;
+    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.
@@ -86,7 +86,7 @@ declare namespace Combinable {
      * c.combine(Maybe.make.none())(Maybe.make.some(5));  // Some(5)
      * ```
      */
-    const maybe: <A>(inner: Combinable<A>) => Combinable<Maybe<A>>;
+    maybe: <A>(inner: Combinable<A>) => Combinable<Maybe<A>>;
     /**
      * Folds an array into a single value using the `Combinable`'s `empty` as the starting point.
      *
@@ -96,7 +96,7 @@ declare namespace Combinable {
      * pipe([], Combinable.fold(Combinable.sum));               // 0
      * ```
      */
-    const fold: <A>(c: Combinable<A>) => (data: readonly A[]) => A;
+    fold: <A>(c: Combinable<A>) => (data: readonly A[]) => A;
     /**
      * Derives a `Combinable` for a record of fields from field-level `Combinable` instances.
      *
@@ -108,8 +108,8 @@ declare namespace Combinable {
      * });
      * ```
      */
-    const struct: <R extends Record<string, unknown>>(fields: { [K in keyof R]: Combinable<R[K]>; }) => Combinable<R>;
-}
+    struct: <R extends Record<string, unknown>>(fields: { [K in keyof R]: Combinable<R[K]>; }) => Combinable<R>;
+};
 
 /**
  * A synchronous memoized computation. The factory function runs exactly once —
@@ -129,7 +129,7 @@ declare namespace Combinable {
 type Lazy<A> = {
     readonly get: () => A;
 };
-declare namespace Lazy {
+declare const Lazy: {
     /**
      * Wraps a thunk in a `Lazy`. The thunk runs exactly once, on first `evaluate`.
      *
@@ -138,7 +138,7 @@ declare namespace Lazy {
      * const expensive = Lazy.from(() => computeExpensiveValue(input));
      * ```
      */
-    const from: <A>(f: () => A) => Lazy<A>;
+    from: <A>(f: () => A) => Lazy<A>;
     /**
      * Forces evaluation and returns the cached result. Safe to call multiple times.
      *
@@ -147,7 +147,7 @@ declare namespace Lazy {
      * const value = Lazy.evaluate(Lazy.from(() => 42)); // 42
      * ```
      */
-    const evaluate: <A>(lazy: Lazy<A>) => A;
+    evaluate: <A>(lazy: Lazy<A>) => A;
     /**
      * Transforms the result of a `Lazy` without triggering evaluation.
      *
@@ -156,7 +156,7 @@ declare namespace Lazy {
      * pipe(Lazy.from(() => loadConfig()), Lazy.map(cfg => cfg.port));
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => (lazy: Lazy<A>) => Lazy<B>;
+    map: <A, B>(f: (a: A) => B) => (lazy: Lazy<A>) => Lazy<B>;
     /**
      * Chains a `Lazy`-returning transformation without triggering evaluation.
      *
@@ -168,7 +168,7 @@ declare namespace Lazy {
      * );
      * ```
      */
-    const chain: <A, B>(f: (a: A) => Lazy<B>) => (lazy: Lazy<A>) => Lazy<B>;
+    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`.
      *
@@ -177,8 +177,8 @@ declare namespace Lazy {
      * pipe(Lazy.from(() => compute()), Lazy.tap(v => console.log("computed:", v)));
      * ```
      */
-    const tap: <A>(f: (a: A) => void) => (lazy: Lazy<A>) => Lazy<A>;
-}
+    tap: <A>(f: (a: A) => void) => (lazy: Lazy<A>) => Lazy<A>;
+};
 
 /**
  * Lens<S, A> focuses on a single value A inside a structure S, providing
@@ -205,8 +205,8 @@ type Lens<S, A> = {
     readonly get: (s: S) => A;
     readonly set: (a: A) => (s: S) => S;
 };
-declare namespace Lens {
-    namespace from {
+declare const Lens: {
+    from: {
         /**
          * Constructs a Lens from a getter and a setter.
          *
@@ -218,7 +218,7 @@ declare namespace Lens {
          * );
          * ```
          */
-        const accessors: <S, A>(get: (s: S) => A, set: (a: A) => (s: S) => S) => Lens<S, A>;
+        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.
@@ -228,8 +228,8 @@ declare namespace Lens {
          * const nameLens = Lens.from.property<User>()("name");
          * ```
          */
-        const property: <S>() => <K extends keyof S>(key: K) => Lens<S, S[K]>;
-    }
+        property: <S>() => <K extends keyof S>(key: K) => Lens<S, S[K]>;
+    };
     /**
      * Reads the focused value from a structure.
      *
@@ -238,7 +238,7 @@ declare namespace Lens {
      * pipe(user, Lens.get(nameLens)); // "Alice"
      * ```
      */
-    const get: <S, A>(lens: Lens<S, A>) => (s: S) => A;
+    get: <S, A>(lens: Lens<S, A>) => (s: S) => A;
     /**
      * Replaces the focused value within a structure, returning a new structure.
      *
@@ -247,7 +247,7 @@ declare namespace Lens {
      * pipe(user, Lens.set(nameLens)("Bob")); // new User with name "Bob"
      * ```
      */
-    const set: <S, A>(lens: Lens<S, A>) => (a: A) => (s: S) => S;
+    set: <S, A>(lens: Lens<S, A>) => (a: A) => (s: S) => S;
     /**
      * Applies a function to the focused value, returning a new structure.
      *
@@ -256,7 +256,7 @@ declare namespace Lens {
      * pipe(user, Lens.modify(nameLens)(n => n.toUpperCase())); // "ALICE"
      * ```
      */
-    const modify: <S, A>(lens: Lens<S, A>) => (f: (a: A) => A) => (s: S) => S;
+    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.
@@ -269,7 +269,7 @@ declare namespace Lens {
      * );
      * ```
      */
-    const andThen: <A, B>(inner: Lens<A, B>) => <S>(outer: Lens<S, A>) => Lens<S, B>;
+    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).
@@ -282,7 +282,7 @@ declare namespace Lens {
      * );
      * ```
      */
-    const andThenOptional: <A, B>(inner: Optional<A, B>) => <S>(outer: Lens<S, A>) => Optional<S, B>;
+    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.
@@ -296,8 +296,8 @@ declare namespace Lens {
      * );
      * ```
      */
-    const toOptional: <S, A>(lens: Lens<S, A>) => Optional<S, A>;
-}
+    toOptional: <S, A>(lens: Lens<S, A>) => Optional<S, A>;
+};
 
 /**
  * A value paired with an accumulated log.
@@ -325,8 +325,8 @@ declare namespace Lens {
  * ```
  */
 type Logged<L, A> = WithValue<A> & WithLog<L>;
-declare namespace Logged {
-    namespace from {
+declare const Logged: {
+    from: {
         /**
          * Wraps a pure value into a `Logged` with an empty log.
          *
@@ -335,7 +335,7 @@ declare namespace Logged {
          * Logged.from.value<string, number>(42); // { value: 42, log: [] }
          * ```
          */
-        const value: <W, A>(val: A) => Logged<W, A>;
+        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`.
@@ -345,8 +345,8 @@ declare namespace Logged {
          * Logged.from.entry("operation completed"); // { value: undefined, log: ["operation completed"] }
          * ```
          */
-        const entry: <W>(logEntry: W) => Logged<W, undefined>;
-    }
+        entry: <W>(logEntry: W) => Logged<W, undefined>;
+    };
     /**
      * Transforms the value inside a `Logged` without affecting the log.
      *
@@ -358,7 +358,7 @@ declare namespace Logged {
      * ); // { value: 10, log: [] }
      * ```
      */
-    const map: <W, A, B>(f: (a: A) => B) => (data: Logged<W, A>) => Logged<W, B>;
+    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
@@ -377,7 +377,7 @@ declare namespace Logged {
      * Logged.run(result); // [20, ["step", "done"]]
      * ```
      */
-    const chain: <W, A, B>(f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, B>;
+    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.
@@ -394,7 +394,7 @@ declare namespace Logged {
      * Logged.run(result); // [10, ["fn-loaded", "arg-loaded"]]
      * ```
      */
-    const ap: <W, A>(arg: Logged<W, A>) => <B>(data: Logged<W, (a: A) => B>) => Logged<W, B>;
+    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.
@@ -407,7 +407,7 @@ declare namespace Logged {
      * );
      * ```
      */
-    const tap: <W, A>(f: (a: A) => void) => (data: Logged<W, A>) => Logged<W, A>;
+    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.
@@ -423,7 +423,7 @@ declare namespace Logged {
      * // value = 2, log = ["incremented"]
      * ```
      */
-    const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+    run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
     /**
      * Lifts a Logged value into an accumulator object.
      *
@@ -432,7 +432,7 @@ declare namespace Logged {
      * pipe(Logged.from.value<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <W, A>(data: Logged<W, A>) => Logged<W, { [P in K]: A; }>;
+    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.
      *
@@ -444,7 +444,7 @@ declare namespace Logged {
      * ); // Logged({ value: { a: 1, b: 2 } })
      * ```
      */
-    const 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; }>;
+    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.
      *
@@ -455,8 +455,8 @@ declare namespace Logged {
      * pipe(logged, Logged.focus(nameLens)(s => s.toUpperCase()));
      * ```
      */
-    const focus: <S, A>(lens: Lens<S, A>) => <W>(f: (a: A) => A) => (data: Logged<W, S>) => Logged<W, S>;
-}
+    focus: <S, A>(lens: Lens<S, A>) => <W>(f: (a: A) => A) => (data: Logged<W, S>) => Logged<W, S>;
+};
 
 type MaybeRetry<E, O> = O extends {
     retry: RetryOptions<E>;
@@ -541,6 +541,7 @@ type InterpretResult<I, E, A, O> = [O] extends [{
 }] ? 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>;
 /**
  * A reusable description of async work — decoupled from execution strategy and lifetime.
  *
@@ -564,10 +565,10 @@ type InterpretResult<I, E, A, O> = [O] extends [{
  *
  * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
  * manager.subscribe(state => {
- *   if (Op.isPending(state)) showSpinner();
- *   if (Op.isOk(state))      render(state.value);
- *   if (Op.isErr(state))   showError(state.error);
- *   if (Op.isNil(state))     resetUI();
+ *   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);
  * ```
@@ -579,595 +580,219 @@ type Op<I, E, A> = {
      */
     readonly _factory: (input: I, signal: AbortSignal) => Deferred<Result<E, A> | null>;
 };
+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 {
-    /**
-     * The three terminal states of a completed async operation.
-     *
-     * - `Ok` — produced a value.
-     * - `Err` — produced a typed error.
-     * - `Nil` — completed without a value or error. The `reason` field says why:
-     *   `"aborted"` — `abort()` was called; `"dropped"` — a new `run()` was ignored
-     *   because the strategy was already busy; `"replaced"` — a newer `run()` took
-     *   over a call that was already running; `"evicted"` — a newer `run()` took over
-     *   a call that was waiting and had not yet started.
-     */
     type Outcome<E, A> = Ok<A> | Err<E> | Nil;
-    /** A successful outcome with a value. */
     type Ok<A> = WithKind<"OpOk"> & WithValue<A>;
-    /** A failed outcome with a typed error. */
     type Err<E> = WithKind<"OpErr"> & WithError<E>;
-    /**
-     * An outcome that produced nothing. `reason` identifies why:
-     * - `"aborted"` — `abort()` was called explicitly.
-     * - `"dropped"` — the invocation was ignored because the strategy was busy.
-     * - `"replaced"` — a newer invocation took over a call that was already running.
-     * - `"evicted"` — a newer invocation took a slot from a call that was waiting and
-     *   had not yet started (buffered slot, debounce timer, throttle trailing slot).
-     */
     type Nil = WithKind<"OpNil"> & {
         readonly reason: NilReason;
     };
-    /** The reason a `Nil` outcome was produced. */
     type NilReason = "aborted" | "dropped" | "replaced" | "evicted";
-    /** A `Nil` produced by an explicit `abort()` call. */
     type AbortedNil = Nil & {
         readonly reason: "aborted";
     };
-    /** A `Nil` produced when an invocation was silently ignored (strategy was busy). */
     type DroppedNil = Nil & {
         readonly reason: "dropped";
     };
-    /** A `Nil` produced when a newer invocation took over a call that was already running. */
     type ReplacedNil = Nil & {
         readonly reason: "replaced";
     };
-    /** A `Nil` produced when a newer invocation took a slot from a call that was waiting and had not yet started. */
     type EvictedNil = Nil & {
         readonly reason: "evicted";
     };
-    /** The full set of states a manager can emit, including transient states. */
     type State<E, A> = Idle | Pending | Queued | Retrying<E> | Outcome<E, A>;
-    /** The manager has not been run yet (initial state). */
     type Idle = WithKind<"Idle">;
-    /** An operation is in-flight. */
     type Pending = WithKind<"Pending">;
-    /** An operation is waiting in a queue. `position` is 0-indexed (0 = next to run). */
     type Queued = WithKind<"Queued"> & {
         readonly position: number;
     };
-    /** A retry attempt is about to start. */
     type Retrying<E> = WithKind<"Retrying"> & {
         readonly attempt: number;
         readonly lastError: E;
         readonly nextRetryIn?: number;
     };
-    /**
-     * A stateful execution manager. `run()` both emits state transitions through
-     * subscribers and returns a `Deferred` tied to that specific invocation.
-     * `S` is narrowed to only the states reachable for this manager's strategy
-     * and configuration.
-     *
-     * @example
-     * ```ts
-     * const manager = Op.interpret(saveConfig, { strategy: "exclusive" });
-     *
-     * manager.subscribe(state => {
-     *   if (Op.isPending(state)) lockForm();
-     *   if (Op.isOk(state))     toast("Saved");
-     *   if (Op.isErr(state))  toast(`Error: ${state.error.message}`);
-     * });
-     *
-     * // Fire and subscribe (subscriber pattern)
-     * manager.run(formData);
-     *
-     * // Or await the specific invocation's outcome
-     * const result = await manager.run(formData);
-     * if (Op.isNil(result)) return; // dropped — another save was in-flight
-     * ```
-     */
     type Manager<I, E, A, S extends State<E, A>> = {
-        /** The current state. Useful for synchronous reads (e.g., `useSyncExternalStore`). */
         readonly state: S;
-        /**
-         * Submits an invocation. Emits state transitions via subscribers and returns a
-         * `Deferred` that resolves to the terminal outcome for this specific invocation.
-         * `Nil` means this invocation was not executed (dropped, replaced, or aborted).
-         */
         run: (input: I) => Deferred<Exclude<S, Idle | Pending | Queued | Retrying<E>>>;
-        /**
-         * Cancels any in-flight operation and clears the queue.
-         * Every pending `run()` Deferred — including queued invocations — settles to `AbortedNil`.
-         * Resolution is asynchronous; no Deferred hangs indefinitely.
-         */
         abort: () => void;
-        /**
-         * Registers a subscriber for state transitions. Returns an unsubscribe function.
-         * The callback fires immediately with the current state if the manager is not idle.
-         */
         subscribe: (cb: (state: S) => void) => () => void;
-        /** Returns state to Idle. Does not cancel any in-flight operation. */
         reset: () => void;
-        /**
-         * Runs the input immediately, then every `interval` milliseconds.
-         * Returns a stop handle — call it to cancel future runs.
-         */
         poll: (input: I, options: {
             interval: Duration;
         }) => () => void;
     };
-    /**
-     * A stateful manager that maintains independent per-key execution slots.
-     * Different keys run in parallel; the same key follows the `perKey` sub-strategy.
-     * `abort(key)` cancels a specific key; `abort()` cancels all.
-     * `state` is a map of each key's last known state — updated on every transition.
-     *
-     * @example
-     * ```ts
-     * const getUser = Op.interpret(fetchUser, {
-     *   strategy: "keyed",
-     *   key: (input) => input.id,
-     *   perKey: "exclusive",
-     * });
-     *
-     * getUser.subscribe((map) => {
-     *   for (const [id, state] of map) {
-     *     if (Op.isPending(state)) showSpinner(id);
-     *     if (Op.isOk(state))     render(id, state.value);
-     *   }
-     * });
-     *
-     * getUser.run({ id: "user-1" }); // starts key "user-1"
-     * getUser.run({ id: "user-2" }); // starts key "user-2" in parallel
-     * ```
-     */
     type KeyedManager<I, K, E, PerKeyS> = {
-        /** Current state map. Keys are present from first `run()` through their last terminal state. */
         readonly state: ReadonlyMap<K, PerKeyS>;
-        /**
-         * Submits an invocation for the key derived from the input. Returns a `Deferred` tied
-         * to this specific invocation. Same-key behaviour is controlled by `perKey`.
-         */
         run: (input: I) => Deferred<Exclude<PerKeyS, Pending | Retrying<E>>>;
-        /** Cancels the in-flight operation for a specific key, or all keys if omitted. */
         abort: (key?: K) => void;
-        /**
-         * Registers a subscriber. The callback receives a fresh snapshot of the state map
-         * on every transition. Returns an unsubscribe function.
-         * Fires immediately with the current map if any key is active.
-         */
         subscribe: (cb: (state: ReadonlyMap<K, PerKeyS>) => void) => () => void;
-        /** Clears all per-key state and notifies subscribers. Does not cancel in-flight operations. */
         reset: () => void;
-        /**
-         * Runs the input immediately, then every `interval` milliseconds.
-         * Returns a stop handle — call it to cancel future runs.
-         */
         poll: (input: I, options: {
             interval: Duration;
         }) => () => void;
     };
-    /** States reachable by a `once` manager (no retry). */
     type OnceState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `once` manager with retry configured. */
     type RetryableOnceState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `restartable` manager (no retry). */
     type RestartableState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
-    /** States reachable by a `restartable` manager with retry configured. */
     type RetryableRestartableState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
-    /** States reachable by an `exclusive` manager (no retry). */
     type ExclusiveState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by an `exclusive` manager with retry configured. */
     type RetryableExclusiveState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `queue` manager (no retry, no overflow, no dedupe). */
     type QueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
-    /** States reachable by a `queue` manager with retry (no overflow, no dedupe). */
     type RetryableQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
-    /** States reachable by a `queue` manager with `overflow:"drop"` or `dedupe` (no retry). */
     type QueueDropState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `queue` manager with `overflow:"drop"` or `dedupe`, with retry. */
     type RetryableQueueDropState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `queue` manager with `overflow:"replace-last"` and no `dedupe` (no retry). */
     type QueueReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `queue` manager with `overflow:"replace-last"` and no `dedupe`, with retry. */
     type RetryableQueueReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `queue` manager with `overflow:"replace-last"` AND `dedupe` (no retry). */
     type QueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
-    /** States reachable by a `queue` manager with `overflow:"replace-last"` AND `dedupe`, with retry. */
     type RetryableQueueDropAndReplaceState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil | EvictedNil;
-    /** States reachable by a `buffered` manager (no retry). */
     type BufferedState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `buffered` manager with retry configured. */
     type RetryableBufferedState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `debounced` manager (no retry). */
     type DebouncedState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `debounced` manager with retry configured. */
     type RetryableDebouncedState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `throttled` manager (leading-only, no retry). */
     type ThrottledState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `throttled` manager (leading-only, with retry). */
     type RetryableThrottledState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `throttled` manager with `trailing: true` (no retry). */
     type ThrottledTrailingState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `throttled` manager with `trailing: true` and retry. */
     type RetryableThrottledTrailingState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | EvictedNil;
-    /** States reachable by a `concurrent` manager with `overflow: "queue"` (no retry). */
     type ConcurrentQueueState<E, A> = Idle | Pending | Queued | Ok<A> | Err<E> | AbortedNil;
-    /** States reachable by a `concurrent` manager with `overflow: "queue"` and retry. */
     type RetryableConcurrentQueueState<E, A> = Idle | Pending | Queued | Retrying<E> | Ok<A> | Err<E> | AbortedNil;
-    /** States reachable by a `concurrent` manager with `overflow: "drop"` (no retry). */
     type ConcurrentDropState<E, A> = Idle | Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** States reachable by a `concurrent` manager with `overflow: "drop"` and retry. */
     type RetryableConcurrentDropState<E, A> = Idle | Pending | Retrying<E> | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** Per-key state union for a `keyed` manager with `perKey: "exclusive"`. */
     type KeyedExclusivePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | DroppedNil;
-    /** Per-key state union for a `keyed` manager with `perKey: "restartable"`. */
     type KeyedRestartablePerKey<E, A> = Pending | Ok<A> | Err<E> | AbortedNil | ReplacedNil;
     type RetryOptions<E> = RetryOptions<E>;
     type TimeoutOptions<E> = TimeoutOptions<E>;
-    /**
-     * Creates a `Nil` outcome with a reason.
-     *
-     * @example
-     * ```ts
-     * Op.nil("aborted");  // { kind: "OpNil", reason: "aborted" }
-     * Op.nil("dropped");  // { kind: "OpNil", reason: "dropped" }
-     * Op.nil("replaced"); // { kind: "OpNil", reason: "replaced" }
-     * Op.nil("evicted");  // { kind: "OpNil", reason: "evicted" }
-     * ```
-     */
-    const nil: (reason: NilReason) => Nil;
-    /**
-     * Creates an `Op` from an async factory and an error mapper.
-     *
-     * The factory receives an `AbortSignal` and returns a function that takes the input. Capture
-     * the signal in the outer closure and pass it to cancellable APIs like `fetch`. The error
-     * mapper converts any thrown value into a typed error; it is never called for aborts.
-     *
-     * **If the factory ignores the signal**, cancellation silently stops working: the operation
-     * runs to completion and emits `Ok` even after the strategy has aborted it. This is harmless
-     * for `exclusive` and `once` (which do not abort in-flight work), but causes stale `Ok`
-     * emissions on `restartable`, `debounced`, `throttled`, `buffered`, and `queue` strategies
-     * where in-flight runs are regularly replaced or dropped.
-     *
-     * @example
-     * ```ts
-     * // With cancellation — fetch is aborted when the Op is replaced or aborted
-     * const saveProfile = Op.create(
-     *   (signal) => (data: ProfileData) =>
-     *     fetch("/profile", { method: "POST", body: JSON.stringify(data), signal })
-     *       .then(r => {
-     *         if (!r.ok) throw new Error(`${r.status} ${r.statusText}`);
-     *         return r.json() as Promise<ProfileData>;
-     *       }),
-     *   (e) => new ApiError(e),
-     * );
-     *
-     * // No input — fetches the current user; manager.run() takes no arguments
-     * const fetchCurrentUser = Op.create(
-     *   (signal) => () => fetch("/me", { 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(fetchCurrentUser, { strategy: "once" });
-     * manager.run(); // no argument needed
-     * ```
-     */
-    const create: <E, A, I = void>(factory: (signal: AbortSignal) => (input: I) => Promise<A>, onError: (e: unknown) => E) => Op<I, E, A>;
-    /**
-     * Lifts a plain async function into an Op, treating all errors as `unknown`.
-     *
-     * Use this when you have a simple async function that doesn't need custom error mapping.
-     * The signal is passed so the operation can respect cancellation.
-     *
-     * @example
-     * ```ts
-     * const fetchUser = Op.lift((id: number, signal: AbortSignal) =>
-     *   fetch(`/api/users/${id}`, { signal }).then(r => r.json())
-     * );
-     * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
-     * const outcome = await manager.run(42);
-     * if (Op.isOk(outcome)) console.log(outcome.value);
-     * ```
-     */
-    const lift: <I, A>(f: (input: I, signal: AbortSignal) => Promise<A>) => Op<I, unknown, A>;
-    /**
-     * Creates a successful Outcome.
-     *
-     * @example
-     * ```ts
-     * Op.ok(42); // { kind: "OpOk", value: 42 }
-     * ```
-     */
-    const ok: <A>(value: A) => Ok<A>;
-    /**
-     * Creates a failed Outcome with a typed error.
-     *
-     * @example
-     * ```ts
-     * Op.err(new ApiError("not found")); // { kind: "OpErr", error: ApiError }
-     * ```
-     */
-    const err: <E>(error: E) => Err<E>;
-    /**
-     * Returns `true` if the state is `Idle`.
-     *
-     * @example
-     * ```ts
-     * manager.subscribe(state => {
-     *   if (Op.isIdle(state)) hideSpinner();
-     * });
-     * ```
-     */
-    const isIdle: <E, A>(state: State<E, A>) => state is Idle;
-    /**
-     * Returns `true` if the state is `Pending` (an operation is in-flight).
-     *
-     * @example
-     * ```ts
-     * manager.subscribe(state => {
-     *   if (Op.isPending(state)) showSpinner();
-     * });
-     * ```
-     */
-    const isPending: <E, A>(state: State<E, A>) => state is Pending;
-    /**
-     * Returns `true` if the state is `Queued` (an invocation is waiting to run).
-     *
-     * @example
-     * ```ts
-     * manager.subscribe(state => {
-     *   if (Op.isQueued(state)) showQueuePosition(state.position);
-     * });
-     * ```
-     */
-    const isQueued: <E, A>(state: State<E, A>) => state is Queued;
-    /**
-     * Returns `true` if the state is `Retrying`.
-     *
-     * @example
-     * ```ts
-     * manager.subscribe(state => {
-     *   if (Op.isRetrying(state)) showRetryBadge(state.attempt);
-     * });
-     * ```
-     */
-    const isRetrying: <E, A>(state: State<E, A>) => state is Retrying<E>;
-    /**
-     * Returns `true` if the state is `Ok` (the operation produced a value).
-     *
-     * @example
-     * ```ts
-     * manager.subscribe(state => {
-     *   if (Op.isOk(state)) render(state.value);
-     * });
-     * ```
-     */
-    const isOk: <E, A>(state: State<E, A>) => state is Ok<A>;
-    /**
-     * Returns `true` if the state is `Err` (the operation failed with a typed error).
-     *
-     * @example
-     * ```ts
-     * manager.subscribe(state => {
-     *   if (Op.isErr(state)) showError(state.error);
-     * });
-     * ```
-     */
-    const isErr: <E, A>(state: State<E, A>) => state is Err<E>;
-    /**
-     * Returns `true` if the state is `Nil` (the operation completed without a value or error).
-     *
-     * @example
-     * ```ts
-     * manager.subscribe(state => {
-     *   if (Op.isNil(state)) resetUI();
-     * });
-     * ```
-     */
-    const isNil: <E, A>(state: State<E, A>) => state is Nil;
-    /**
-     * Pattern matches on an Outcome using named case handlers.
-     *
-     * @example
-     * ```ts
-     * Op.match({
-     *   ok:  (user) => render(user),
-     *   err: (e)    => showError(e.message),
-     *   nil: ()     => resetUI(),
-     * })(outcome);
-     * ```
-     */
-    const match: <E, A, B>(cases: {
-        ok: (a: A) => B;
-        err: (e: E) => B;
-        nil: () => B;
-    }) => (outcome: Outcome<E, A>) => B;
-    /**
-     * Eliminates an Outcome with positional handlers.
-     * Order: `onErr`, `onNil`, `onOk` — mirrors `Result.fold` for the first and last cases.
-     *
-     * @example
-     * ```ts
-     * Op.fold(
-     *   (e) => `error: ${e.message}`,
-     *   ()  => "nothing",
-     *   (v) => `value: ${v}`,
-     * )(outcome);
-     * ```
-     */
-    const fold: <E, A, B>(onErr: (e: E) => B, onNil: () => B, onOk: (a: A) => B) => (outcome: Outcome<E, A>) => B;
-    /**
-     * Returns the success value, or the result of `defaultValue()` for `Err` or `Nil`.
-     *
-     * @example
-     * ```ts
-     * Op.getOrElse(() => [] as User[])(outcome);
-     * ```
-     */
-    const getOrElse: <E, A, B>(defaultValue: () => B) => (outcome: Outcome<E, A>) => A | B;
-    /**
-     * Transforms the success value. `Err` and `Nil` pass through unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(outcome, Op.map(user => user.name));
-     * ```
-     */
-    const map: <E, A, B>(f: (a: A) => B) => (outcome: Outcome<E, A>) => Outcome<E, B>;
-    /**
-     * Transforms the error value. `Ok` and `Nil` pass through unchanged.
-     *
-     * @example
-     * ```ts
-     * pipe(outcome, Op.mapError(e => e.message));
-     * ```
-     */
-    const mapError: <E, F, A>(f: (e: E) => F) => (outcome: Outcome<E, A>) => Outcome<F, A>;
-    /**
-     * Chains Outcome computations. Runs `f` on `Ok`; `Err` and `Nil` pass through.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   outcome,
-     *   Op.chain(user => user.active ? Op.ok(user) : Op.err(new Error("inactive"))),
-     * );
-     * ```
-     */
-    const chain: <E, A, B>(f: (a: A) => Outcome<E, B>) => (outcome: Outcome<E, A>) => Outcome<E, B>;
-    /**
-     * Runs a side effect on the success value without changing the Outcome.
-     *
-     * @example
-     * ```ts
-     * pipe(outcome, Op.tap(user => console.log("loaded", user.id)));
-     * ```
-     */
-    const tap: <E, A>(f: (a: A) => void) => (outcome: Outcome<E, A>) => Outcome<E, A>;
-    /**
-     * Provides a fallback Outcome when the result is `Err`. `Ok` and `Nil` pass through.
-     *
-     * @example
-     * ```ts
-     * pipe(
-     *   outcome,
-     *   Op.recover(e => e.isRetryable ? Op.ok(cachedValue) : Op.err(e)),
-     * );
-     * ```
-     */
-    const recover: <E, A, B>(f: (e: E) => Outcome<E, B>) => (outcome: Outcome<E, A>) => Outcome<E, A | B>;
-    /**
-     * Converts an Outcome to a `Result`. `Nil` becomes `Err(onNil())`.
-     *
-     * @example
-     * ```ts
-     * Op.to.Result(() => new ApiError("no result"))(outcome);
-     * ```
-     */
-    namespace to {
-        /**
-         * Converts an Outcome to a `Result`. `Nil` becomes `Err(onNil())`.
-         *
-         * @example
-         * ```ts
-         * Op.to.Result(() => new ApiError("no result"))(outcome);
-         * ```
-         */
-        const Result: <E, A>(onNil: () => E) => (outcome: Outcome<E, A>) => Result<E, A>;
-        /**
-         * Converts an Outcome to a `Maybe`. `Ok` becomes `Some`; `Err` and `Nil` become `None`.
-         *
-         * @example
-         * ```ts
-         * Op.to.Maybe(outcome); // Maybe<User>
-         * ```
-         */
-        const Maybe: <E, A>(outcome: Outcome<E, A>) => Maybe<A>;
-    }
-    /**
-     * Resolves when all invocations settle, returning their outcomes in order.
-     * An alternative to `Promise.all` that stays within the `Op` type system.
-     *
-     * @example
-     * ```ts
-     * const [a, b] = await Op.all([manager.run(inputA), manager.run(inputB)]);
-     * ```
-     */
-    const all: <E, A>(invocations: ReadonlyArray<Deferred<Outcome<E, A>>>) => Deferred<ReadonlyArray<Outcome<E, A>>>;
-    /**
-     * Resolves to the outcome of whichever invocation settles first.
-     * An alternative to `Promise.race` that stays within the `Op` type system.
-     *
-     * @example
-     * ```ts
-     * const winner = await Op.race([manager.run(inputA), manager.run(inputB)]);
-     * ```
-     */
-    const race: <E, A>(invocations: ReadonlyArray<Deferred<Outcome<E, A>>>) => Deferred<Outcome<E, A>>;
-    /**
-     * Subscribes to a manager and calls a handler when the state reaches `OpOk`.
-     * Returns an unsubscribe function.
-     *
-     * @example
-     * ```ts
-     * const manager = Op.interpret(fetchUser, { strategy: "restartable" });
-     * const stop = Op.wire(manager, (user) => {
-     *   console.log("User loaded:", user.name);
-     * });
-     * manager.run(userId);
-     * // ... later
-     * stop(); // removes the subscription
-     * ```
-     */
-    const wire: <I, E, A, S extends State<E, A>>(source: Manager<I, E, A, S>, f: (a: A) => void) => () => void;
-    /**
-     * Attaches a concurrency strategy to an `Op`, returning a `Manager`.
-     *
-     * Strategy is data, not a method name. The `S` type parameter is narrowed to only
-     * the states reachable for the chosen strategy and options — subscribers cannot
-     * reference states that cannot occur.
-     *
-     * **Strategies:**
-     * - `once`        — fires once. Only the first `run()` executes; subsequent calls
-     *                   return `DroppedNil` immediately. State is permanent after completion.
-     * - `restartable` — new call cancels the previous (`ReplacedNil`). Only the latest result matters.
-     * - `exclusive`   — new calls while in-flight return `DroppedNil` immediately.
-     * - `queue`       — calls run in submission order. `Queued` state shows position.
-     * - `buffered`    — 1 in-flight + 1 waiting slot. Newer calls evict the slot (`EvictedNil`).
-     * - `debounced`   — waits `ms` ms of quiet before starting. Earlier calls get `EvictedNil`.
-     *
-     * **`retry` and `timeout`** can be combined with any strategy. Both are applied
-     * internally per `run()` call — set the policy once, not at every call site.
-     * The timeout wraps the entire retry sequence (one deadline for all attempts).
-     * When `retry` is present, `Retrying` is added to the subscriber type.
-     *
-     * @example
-     * ```ts
-     * // Load once on mount — further calls are no-ops
-     * const getUser = Op.interpret(fetchUser, { strategy: "once" });
-     * getUser.subscribe(state => {
-     *   if (state.kind === "Pending") showSpinner();
-     *   if (state.kind === "OpOk")      render(state.value);
-     * });
-     * getUser.run(userId);
-     *
-     * // Search: cancel the previous query when a new one starts
-     * const search = Op.interpret(searchOp, { strategy: "restartable" });
-     *
-     * // Form submit: ignore double-clicks while in-flight
-     * const submit = Op.interpret(submitOp, {
-     *   strategy: "exclusive",
-     *   retry: { attempts: 3, backoff: n => n * 500 },
-     *   timeout: { ms: 10_000, onTimeout: () => new ApiError("timed out") },
-     * });
-     *
-     * // Auto-save: current save commits fully; latest pending edit saves next
-     * const save = Op.interpret(saveOp, { strategy: "buffered" });
-     * ```
-     */
-    function interpret<I, E, A, O extends AllInterpretOptions<I, E>>(op: Op<I, E, A>, options: O): InterpretResult<I, E, A, O>;
 }
 
 /** Keys of T for which undefined is assignable (i.e. optional fields). */
@@ -1196,8 +821,8 @@ type Optional<S, A> = {
     readonly get: (s: S) => Maybe<A>;
     readonly set: (a: A) => (s: S) => S;
 };
-declare namespace Optional {
-    namespace from {
+declare const Optional: {
+    from: {
         /**
          * Constructs an Optional from a getter (returning Maybe<A>) and a setter.
          *
@@ -1209,7 +834,7 @@ declare namespace Optional {
          * );
          * ```
          */
-        const accessors: <S, A>(get: (s: S) => Maybe<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
+        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.
@@ -1221,8 +846,8 @@ declare namespace Optional {
          * const bioOpt = Optional.from.property<Profile>()("bio");
          * ```
          */
-        const property: <S>() => <K extends OptionalKeys<S>>(key: K) => Optional<S, NonNullable<S[K]>>;
-    }
+        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.
@@ -1235,7 +860,7 @@ declare namespace Optional {
      * pipe([], Optional.get(firstItem));         // None
      * ```
      */
-    const index: <A>(i: number) => Optional<A[], A>;
+    index: <A>(i: number) => Optional<A[], A>;
     /**
      * Reads the focused value from a structure, returning Maybe<A>.
      *
@@ -1244,7 +869,7 @@ declare namespace Optional {
      * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
      * ```
      */
-    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Maybe<A>;
+    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.
@@ -1254,7 +879,7 @@ declare namespace Optional {
      * pipe(profile, Optional.set(bioOpt)("hello"));
      * ```
      */
-    const set: <S, A>(opt: Optional<S, A>) => (a: A) => (s: S) => S;
+    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.
@@ -1264,7 +889,7 @@ declare namespace Optional {
      * pipe(profile, Optional.modify(bioOpt)(s => s.toUpperCase()));
      * ```
      */
-    const modify: <S, A>(opt: Optional<S, A>) => (f: (a: A) => A) => (s: S) => S;
+    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.
      *
@@ -1273,7 +898,7 @@ declare namespace Optional {
      * pipe(profile, Optional.getOrElse(bioOpt)(() => "no bio"));
      * ```
      */
-    const getOrElse: <S, A>(opt: Optional<S, A>) => (defaultValue: () => A) => (s: S) => A;
+    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.
@@ -1283,7 +908,7 @@ declare namespace Optional {
      * pipe(profile, Optional.fold(bioOpt)(() => "no bio", (bio) => bio.toUpperCase()));
      * ```
      */
-    const fold: <S, A>(opt: Optional<S, A>) => <B>(onNone: () => B, onSome: (a: A) => B) => (s: S) => B;
+    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.
      *
@@ -1295,7 +920,7 @@ declare namespace Optional {
      * );
      * ```
      */
-    const match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
+    match: <S, A>(opt: Optional<S, A>) => <B>(cases: {
         none: () => B;
         some: (a: A) => B;
     }) => (s: S) => B;
@@ -1311,7 +936,7 @@ declare namespace Optional {
      * );
      * ```
      */
-    const andThen: <A, B>(inner: Optional<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
+    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.
@@ -1324,8 +949,8 @@ declare namespace Optional {
      * );
      * ```
      */
-    const andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
-}
+    andThenLens: <A, B>(inner: Lens<A, B>) => <S>(outer: Optional<S, A>) => Optional<S, B>;
+};
 
 /**
  * Pair<A, B> represents a pair of two values that are always both present.
@@ -1350,8 +975,8 @@ declare namespace Optional {
  * ```
  */
 type Pair<A, B> = readonly [A, B];
-declare namespace Pair {
-    namespace from {
+declare const Pair: {
+    from: {
         /**
          * Creates a Pair from two values.
          *
@@ -1360,7 +985,7 @@ declare namespace Pair {
          * Pair.from.pair("Paris", 2_161_000); // ["Paris", 2161000]
          * ```
          */
-        const pair: <A, B>(first: A, second: B) => Pair<A, B>;
+        pair: <A, B>(first: A, second: B) => Pair<A, B>;
         /**
          * Creates a Pair from a two-element array.
          *
@@ -1369,8 +994,8 @@ declare namespace Pair {
          * Pair.from.array(["Paris", 2_161_000] as const); // ["Paris", 2161000]
          * ```
          */
-        const array: <A, B>(arr: readonly [A, B]) => Pair<A, B>;
-    }
+        array: <A, B>(arr: readonly [A, B]) => Pair<A, B>;
+    };
     /**
      * Returns the first value from the pair.
      *
@@ -1379,7 +1004,7 @@ declare namespace Pair {
      * Pair.first(Pair.from.pair("Paris", 2_161_000)); // "Paris"
      * ```
      */
-    const first: <A, B>(p: Pair<A, B>) => A;
+    first: <A, B>(p: Pair<A, B>) => A;
     /**
      * Returns the second value from the pair.
      *
@@ -1388,7 +1013,7 @@ declare namespace Pair {
      * Pair.second(Pair.from.pair("Paris", 2_161_000)); // 2161000
      * ```
      */
-    const second: <A, B>(p: Pair<A, B>) => B;
+    second: <A, B>(p: Pair<A, B>) => B;
     /**
      * Transforms the first value, leaving the second unchanged.
      *
@@ -1397,7 +1022,7 @@ declare namespace Pair {
      * pipe(Pair.from.pair("alice", 42), Pair.mapFirst((s) => s.toUpperCase())); // ["ALICE", 42]
      * ```
      */
-    const mapFirst: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
+    mapFirst: <A, C>(f: (a: A) => C) => <B>(p: Pair<A, B>) => Pair<C, B>;
     /**
      * Transforms the second value, leaving the first unchanged.
      *
@@ -1406,7 +1031,7 @@ declare namespace Pair {
      * pipe(Pair.from.pair("alice", 42), Pair.mapSecond((n) => n * 2)); // ["alice", 84]
      * ```
      */
-    const mapSecond: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
+    mapSecond: <B, D>(f: (b: B) => D) => <A>(p: Pair<A, B>) => Pair<A, D>;
     /**
      * Transforms both values independently in a single step.
      *
@@ -1421,7 +1046,7 @@ declare namespace Pair {
      * ); // ["ALICE", 84]
      * ```
      */
-    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (p: Pair<A, B>) => Pair<C, D>;
+    mapBoth: <A, C, B, D>(onFirst: (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.
@@ -1432,7 +1057,7 @@ declare namespace Pair {
      * // "Alice: 100"
      * ```
      */
-    const fold: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
+    fold: <A, B, C>(f: (a: A, b: B) => C) => (p: Pair<A, B>) => C;
     /**
      * Swaps the two values: `[A, B]` becomes `[B, A]`.
      *
@@ -1441,8 +1066,8 @@ declare namespace Pair {
      * Pair.swap(Pair.from.pair("key", 1)); // [1, "key"]
      * ```
      */
-    const swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
-    namespace to {
+    swap: <A, B>(p: Pair<A, B>) => Pair<B, A>;
+    to: {
         /**
          * Converts the pair to a heterogeneous readonly array `readonly (A | B)[]`.
          *
@@ -1451,8 +1076,8 @@ declare namespace Pair {
          * Pair.to.Array(Pair.from.pair("hello", 42)); // ["hello", 42]
          * ```
          */
-        const Array: <A, B>(p: Pair<A, B>) => readonly (A | B)[];
-    }
+        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.
@@ -1466,8 +1091,8 @@ declare namespace Pair {
      * ); // logs "Paris: 2161000", returns ["Paris", 2.161]
      * ```
      */
-    const tap: <A, B>(f: (a: A, b: B) => void) => (p: Pair<A, B>) => Pair<A, B>;
-}
+    tap: <A, B>(f: (a: A, b: B) => void) => (p: Pair<A, B>) => Pair<A, B>;
+};
 
 /**
  * A boolean-valued function over a type `A`.
@@ -1496,7 +1121,7 @@ declare namespace Pair {
  * ```
  */
 type Predicate<A> = (a: A) => boolean;
-declare namespace Predicate {
+declare const Predicate: {
     /**
      * Negates a predicate: the result passes exactly when the original fails.
      *
@@ -1509,7 +1134,7 @@ declare namespace Predicate {
      * isNotBlank("   ");    // false
      * ```
      */
-    const not: <A>(p: Predicate<A>) => Predicate<A>;
+    not: <A>(p: Predicate<A>) => Predicate<A>;
     /**
      * Combines two predicates with logical AND: passes only when both hold.
      *
@@ -1527,7 +1152,7 @@ declare namespace Predicate {
      * isPositiveEven(-2);  // false — even but not positive
      * ```
      */
-    const and: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>;
+    and: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>;
     /**
      * Combines two predicates with logical OR: passes when either holds.
      *
@@ -1545,7 +1170,7 @@ declare namespace Predicate {
      * getsDiscount(30);  // false
      * ```
      */
-    const or: <A>(second: Predicate<A>) => (first: Predicate<A>) => Predicate<A>;
+    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.
@@ -1568,7 +1193,7 @@ declare namespace Predicate {
      * isAdultUser({ name: "Bob",   age: 15 });  // false
      * ```
      */
-    const using: <A, B>(f: (b: B) => A) => (p: Predicate<A>) => Predicate<B>;
+    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).
@@ -1587,7 +1212,7 @@ declare namespace Predicate {
      * Predicate.all([])("anything");   // true
      * ```
      */
-    const all: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<A>;
+    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.
@@ -1605,8 +1230,8 @@ declare namespace Predicate {
      * Predicate.any([])("anything");                 // false
      * ```
      */
-    const any: <A>(predicates: ReadonlyArray<Predicate<A>>) => Predicate<A>;
-    namespace from {
+    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
@@ -1629,8 +1254,8 @@ declare namespace Predicate {
          * isShortString(42);              // false
          * ```
          */
-        const Refinement: <A, B extends A>(r: Refinement<A, B>) => Predicate<A>;
-    }
+        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.
@@ -1647,8 +1272,8 @@ declare namespace Predicate {
      * classifyNumber(-5); // "negative"
      * ```
      */
-    const match: <A, B>(branches: ReadonlyArray<readonly [Predicate<A>, (a: A) => B]>, fallback: (a: A) => B) => (a: A) => B;
-}
+    match: <A, B>(branches: ReadonlyArray<readonly [Predicate<A>, (a: A) => B]>, fallback: (a: A) => B) => (a: A) => B;
+};
 
 /**
  * A computation that reads from a shared environment `R` and produces a value `A`.
@@ -1676,7 +1301,7 @@ declare namespace Predicate {
  * ```
  */
 type Reader<R, A> = (env: R) => A;
-declare namespace Reader {
+declare const Reader: {
     /**
      * Lifts a pure value into a Reader. The environment is ignored.
      *
@@ -1686,7 +1311,7 @@ declare namespace Reader {
      * always42(anyConfig); // 42
      * ```
      */
-    const resolve: <R, A>(value: A) => Reader<R, A>;
+    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.
@@ -1699,7 +1324,7 @@ declare namespace Reader {
      * )(appConfig); // "https://api.example.com"
      * ```
      */
-    const ask: <R>() => Reader<R, R>;
+    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.
@@ -1710,7 +1335,7 @@ declare namespace Reader {
      * getBaseUrl(appConfig); // "https://api.example.com"
      * ```
      */
-    const asks: <R, A>(f: (env: R) => A) => Reader<R, A>;
+    asks: <R, A>(f: (env: R) => A) => Reader<R, A>;
     /**
      * Transforms the value produced by a Reader.
      *
@@ -1722,7 +1347,7 @@ declare namespace Reader {
      * )(appConfig); // "HTTPS://API.EXAMPLE.COM"
      * ```
      */
-    const map: <R, A, B>(f: (a: A) => B) => (data: Reader<R, A>) => Reader<R, B>;
+    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.
@@ -1741,7 +1366,7 @@ declare namespace Reader {
      * )(appConfig); // "https://api.example.com/items?key=secret"
      * ```
      */
-    const chain: <R, A, B>(f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, B>;
+    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.
@@ -1756,7 +1381,7 @@ declare namespace Reader {
      * )(appConfig);
      * ```
      */
-    const ap: <R, A>(arg: Reader<R, A>) => <B>(data: Reader<R, (a: A) => B>) => Reader<R, B>;
+    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.
@@ -1770,7 +1395,7 @@ declare namespace Reader {
      * )(appConfig);
      * ```
      */
-    const tap: <R, A>(f: (a: A) => void) => (data: Reader<R, A>) => Reader<R, A>;
+    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.
@@ -1790,7 +1415,7 @@ declare namespace Reader {
      * buildUrlFromApp(appEnv); // works with the full AppEnv
      * ```
      */
-    const local: <R2, R>(f: (env: R2) => R) => <A>(data: Reader<R, A>) => Reader<R2, A>;
+    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.
@@ -1803,7 +1428,7 @@ declare namespace Reader {
      * ); // "https://api.example.com/users?key=secret"
      * ```
      */
-    const run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
+    run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
     /**
      * Lifts a Reader value into an accumulator object.
      *
@@ -1812,7 +1437,7 @@ declare namespace Reader {
      * pipe(Reader.resolve(42), Reader.bindTo("value")); // Reader({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <R, A>(data: Reader<R, A>) => Reader<R, { [P in K]: A; }>;
+    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.
      *
@@ -1824,8 +1449,8 @@ declare namespace Reader {
      * ); // Reader({ a: 1, b: 2 })
      * ```
      */
-    const 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; }>;
-}
+    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; }>;
+};
 
 /**
  * A function from `A` to `A is B` — a type predicate paired with a runtime check.
@@ -1850,8 +1475,8 @@ declare namespace Reader {
  * ```
  */
 type Refinement<A, B extends A> = (a: A) => a is B;
-declare namespace Refinement {
-    namespace from {
+declare const Refinement: {
+    from: {
         /**
          * Creates a `Refinement<A, B>` from a plain boolean predicate.
          *
@@ -1868,8 +1493,8 @@ declare namespace Refinement {
          *   Refinement.from.predicate(n => n > 0);
          * ```
          */
-        const predicate: <A, B extends A>(f: (a: A) => boolean) => Refinement<A, B>;
-    }
+        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`.
@@ -1892,7 +1517,7 @@ declare namespace Refinement {
      * );
      * ```
      */
-    const compose: <A, B extends A, C extends B>(bc: Refinement<B, C>) => (ab: Refinement<A, B>) => Refinement<A, C>;
+    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.
@@ -1910,7 +1535,7 @@ declare namespace Refinement {
      * isNonEmptyString("");    // false
      * ```
      */
-    const and: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B & C>;
+    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.
@@ -1928,8 +1553,8 @@ declare namespace Refinement {
      * isStringOrNumber(true); // false
      * ```
      */
-    const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
-    namespace to {
+    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>`.
          *
@@ -1946,7 +1571,7 @@ declare namespace Refinement {
          * pipe(42, Refinement.to.Maybe(isPositive)); // Some(42)
          * ```
          */
-        const Maybe: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Maybe<B>;
+        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>`.
          *
@@ -1963,9 +1588,9 @@ declare namespace Refinement {
          * pipe("hi", Refinement.to.Result(isNonEmpty, () => "must not be empty")); // Ok("hi")
          * ```
          */
-        const Result: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
-    }
-}
+        Result: <A, B extends A, E>(r: Refinement<A, B>, onFail: (a: A) => E) => (a: A) => Result<E, B>;
+    };
+};
 
 type NotAsked = WithKind<"NotAsked">;
 type Loading = WithKind<"Loading">;
@@ -1992,8 +1617,8 @@ type Success<A> = WithKind<"Success"> & WithValue<A>;
  * ```
  */
 type RemoteData<E, A> = NotAsked | Loading | Failure<E> | Success<A>;
-declare namespace RemoteData {
-    namespace make {
+declare const RemoteData: {
+    make: {
         /**
          * Creates a NotAsked RemoteData.
          *
@@ -2002,7 +1627,7 @@ declare namespace RemoteData {
          * RemoteData.make.notAsked(); // NotAsked
          * ```
          */
-        const notAsked: () => NotAsked;
+        notAsked: () => NotAsked;
         /**
          * Creates a Loading RemoteData.
          *
@@ -2011,7 +1636,7 @@ declare namespace RemoteData {
          * RemoteData.make.loading(); // Loading
          * ```
          */
-        const loading: () => Loading;
+        loading: () => Loading;
         /**
          * Creates a Failure RemoteData with the given error.
          *
@@ -2020,7 +1645,7 @@ declare namespace RemoteData {
          * RemoteData.make.failure("Network error"); // Failure("Network error")
          * ```
          */
-        const failure: <E>(error: E) => Failure<E>;
+        failure: <E>(error: E) => Failure<E>;
         /**
          * Creates a Success RemoteData with the given value.
          *
@@ -2029,9 +1654,9 @@ declare namespace RemoteData {
          * RemoteData.make.success(42); // Success(42)
          * ```
          */
-        const success: <A>(value: A) => Success<A>;
-    }
-    namespace is {
+        success: <A>(value: A) => Success<A>;
+    };
+    is: {
         /**
          * Type guard that checks if a RemoteData is NotAsked.
          *
@@ -2043,7 +1668,7 @@ declare namespace RemoteData {
          * }
          * ```
          */
-        const notAsked: <E, A>(data: RemoteData<E, A>) => data is NotAsked;
+        notAsked: <E, A>(data: RemoteData<E, A>) => data is NotAsked;
         /**
          * Type guard that checks if a RemoteData is Loading.
          *
@@ -2055,7 +1680,7 @@ declare namespace RemoteData {
          * }
          * ```
          */
-        const loading: <E, A>(data: RemoteData<E, A>) => data is Loading;
+        loading: <E, A>(data: RemoteData<E, A>) => data is Loading;
         /**
          * Type guard that checks if a RemoteData is Failure.
          *
@@ -2067,7 +1692,7 @@ declare namespace RemoteData {
          * }
          * ```
          */
-        const failure: <E, A>(data: RemoteData<E, A>) => data is Failure<E>;
+        failure: <E, A>(data: RemoteData<E, A>) => data is Failure<E>;
         /**
          * Type guard that checks if a RemoteData is Success.
          *
@@ -2079,8 +1704,8 @@ declare namespace RemoteData {
          * }
          * ```
          */
-        const success: <E, A>(data: RemoteData<E, A>) => data is Success<A>;
-    }
+        success: <E, A>(data: RemoteData<E, A>) => data is Success<A>;
+    };
     /**
      * Transforms the success value inside a RemoteData.
      *
@@ -2090,7 +1715,7 @@ declare namespace RemoteData {
      * pipe(RemoteData.make.loading(), RemoteData.map(n => n * 2)); // Loading
      * ```
      */
-    const map: <A, B>(f: (a: A) => B) => <E>(data: RemoteData<E, A>) => RemoteData<E, B>;
+    map: <A, B>(f: (a: A) => B) => <E>(data: RemoteData<E, A>) => RemoteData<E, B>;
     /**
      * Transforms the error value inside a RemoteData.
      *
@@ -2099,7 +1724,7 @@ declare namespace RemoteData {
      * pipe(RemoteData.make.failure("oops"), RemoteData.mapError(e => e.toUpperCase())); // Failure("OOPS")
      * ```
      */
-    const mapError: <E, F>(f: (e: E) => F) => <A>(data: RemoteData<E, A>) => RemoteData<F, A>;
+    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.
@@ -2112,7 +1737,7 @@ declare namespace RemoteData {
      * );
      * ```
      */
-    const chain: <E2, A, B>(f: (a: A) => RemoteData<E2, B>) => <E1 = never>(data: RemoteData<E1, A>) => RemoteData<E1 | E2, B>;
+    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.
      *
@@ -2126,7 +1751,7 @@ declare namespace RemoteData {
      * ); // Success(8)
      * ```
      */
-    const ap: <E, A>(arg: RemoteData<E, A>) => <B>(data: RemoteData<E, (a: A) => B>) => RemoteData<E, B>;
+    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.
      *
@@ -2143,7 +1768,7 @@ declare namespace RemoteData {
      * );
      * ```
      */
-    const fold: <E, A, B>(onFailure: (e: E) => B, onNotAsked: () => B, onLoading: () => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
+    fold: <E, A, B>(onFailure: (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.
      *
@@ -2160,7 +1785,7 @@ declare namespace RemoteData {
      * );
      * ```
      */
-    const match: <E, A, B>(cases: {
+    match: <E, A, B>(cases: {
         notAsked: () => B;
         loading: () => B;
         failure: (e: E) => B;
@@ -2177,7 +1802,7 @@ declare namespace RemoteData {
      * pipe(RemoteData.make.loading<string, number>(), RemoteData.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
-    const getOrElse: <B>(defaultValue: () => B) => <E, A>(data: RemoteData<E, A>) => A | B;
+    getOrElse: <B>(defaultValue: () => B) => <E, A>(data: RemoteData<E, A>) => A | B;
     /**
      * Executes a side effect on the success value without changing the RemoteData.
      *
@@ -2190,7 +1815,7 @@ declare namespace RemoteData {
      * );
      * ```
      */
-    const tap: <E, A>(f: (a: A) => void) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+    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.
@@ -2204,18 +1829,18 @@ declare namespace RemoteData {
      * );
      * ```
      */
-    const tapError: <E, A>(f: (e: E) => void) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+    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>`.
      */
-    const recover: <E, B>(fallback: (e: E) => RemoteData<E, B>) => <A>(data: RemoteData<E, A>) => RemoteData<E, A | B>;
-    namespace to {
+    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.
          */
-        const Maybe: <E, A>(data: RemoteData<E, A>) => Maybe<A>;
+        Maybe: <E, A>(data: RemoteData<E, A>) => Maybe<A>;
         /**
          * Converts a RemoteData to a Result.
          * Success becomes Ok, Failure becomes Err.
@@ -2229,9 +1854,9 @@ declare namespace RemoteData {
          * ); // Ok(42)
          * ```
          */
-        const Result: <E>(onNotReady: () => E) => <A>(data: RemoteData<E, A>) => Result<E, A>;
-    }
-    namespace from {
+        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.
@@ -2242,7 +1867,7 @@ declare namespace RemoteData {
          * setState(RemoteData.from.Result(result)); // Success(user) or Failure(msg)
          * ```
          */
-        const Result: <E, A>(data: Result<E, A>) => RemoteData<E, A>;
+        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.
@@ -2253,8 +1878,8 @@ declare namespace RemoteData {
          * pipe(Maybe.make.none(), RemoteData.from.Maybe(() => "not found"));     // Failure("not found")
          * ```
          */
-        const Maybe: <E>(onNone: () => E) => <A>(data: Maybe<A>) => RemoteData<E, A>;
-    }
+        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.
@@ -2268,8 +1893,8 @@ declare namespace RemoteData {
      * RemoteData.filter(n => n > 0, () => "error")(RemoteData.make.loading()); // Loading
      * ```
      */
-    const filter: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (data: RemoteData<E, A>) => RemoteData<E, A>;
-}
+    filter: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (data: RemoteData<E, A>) => RemoteData<E, A>;
+};
 
 /**
  * A Resource pairs an async acquisition step with a guaranteed cleanup step.
@@ -2303,8 +1928,8 @@ type Resource<E, A> = {
     readonly acquire: Task.Result<E, A>;
     readonly release: (a: A) => Task<void>;
 };
-declare namespace Resource {
-    namespace from {
+declare const Resource: {
+    from: {
         /**
          * Creates a Resource from an acquire operation that may fail and a release function.
          *
@@ -2316,7 +1941,7 @@ declare namespace Resource {
          * );
          * ```
          */
-        const handlers: <E, A>(acquire: Task.Result<E, A>, release: (a: A) => Task<void>) => Resource<E, A>;
+        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
@@ -2330,8 +1955,8 @@ declare namespace Resource {
          * );
          * ```
          */
-        const Task: <E, A>(acquire: Task<A>, release: (a: A) => Task<void>) => Resource<E, A>;
-    }
+        Task: <E, A>(acquire: Task<A>, release: (a: A) => Task<void>) => Resource<E, A>;
+    };
     /**
      * Acquires the resource, runs `f` with it, then releases it.
      *
@@ -2347,7 +1972,7 @@ declare namespace Resource {
      * // conn is closed whether the query succeeds or fails
      * ```
      */
-    const use: <E, A, B>(f: (a: A) => Task.Result<E, B>) => (resource: Resource<E, A>) => Task.Result<E, B>;
+    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.
@@ -2365,8 +1990,8 @@ declare namespace Resource {
      * )();
      * ```
      */
-    const combine: <E, A, B>(resourceA: Resource<E, A>, resourceB: Resource<E, B>) => Resource<E, readonly [A, B]>;
-}
+    combine: <E, A, B>(resourceA: Resource<E, A>, resourceB: Resource<E, B>) => Resource<E, readonly [A, B]>;
+};
 
 /**
  * A synchronous computation that threads a piece of mutable state `S` through
@@ -2393,7 +2018,7 @@ declare namespace Resource {
  * ```
  */
 type State<S, A> = (s: S) => readonly [A, S];
-declare namespace State {
+declare const State: {
     /**
      * Lifts a pure value into a State computation. The state passes through unchanged.
      *
@@ -2402,7 +2027,7 @@ declare namespace State {
      * State.run(10)(State.resolve(42)); // [42, 10] — value 42, state unchanged
      * ```
      */
-    const resolve: <S, A>(value: A) => State<S, A>;
+    resolve: <S, A>(value: A) => State<S, A>;
     /**
      * Produces the current state as the value, without modifying it.
      *
@@ -2412,7 +2037,7 @@ declare namespace State {
      * State.run(["a", "b"])(readStack); // [["a", "b"], ["a", "b"]]
      * ```
      */
-    const get: <S>() => State<S, S>;
+    get: <S>() => State<S, S>;
     /**
      * Reads a projection of the state without modifying it.
      * Equivalent to `pipe(State.get(), State.map(f))` but more direct.
@@ -2424,7 +2049,7 @@ declare namespace State {
      * State.run({ count: 5, label: "x" })(readCount); // [5, { count: 5, label: "x" }]
      * ```
      */
-    const gets: <S, A>(f: (s: S) => A) => State<S, A>;
+    gets: <S, A>(f: (s: S) => A) => State<S, A>;
     /**
      * Replaces the current state with a new value. Produces no meaningful value.
      *
@@ -2434,7 +2059,7 @@ declare namespace State {
      * State.run(99)(reset); // [undefined, 0]
      * ```
      */
-    const put: <S>(newState: S) => State<S, undefined>;
+    put: <S>(newState: S) => State<S, undefined>;
     /**
      * Applies a function to the current state to produce the next state.
      * Produces no meaningful value.
@@ -2447,7 +2072,7 @@ declare namespace State {
      * State.run(["a"])(push("b")); // [undefined, ["a", "b"]]
      * ```
      */
-    const modify: <S>(f: (s: S) => S) => State<S, undefined>;
+    modify: <S>(f: (s: S) => S) => State<S, undefined>;
     /**
      * Transforms the value produced by a State computation.
      * The state transformation is unchanged.
@@ -2462,7 +2087,7 @@ declare namespace State {
      * State.run(["a", "b", "c"])(readLength); // [3, ["a", "b", "c"]]
      * ```
      */
-    const map: <S, A, B>(f: (a: A) => B) => (st: State<S, A>) => State<S, B>;
+    map: <S, A, B>(f: (a: A) => B) => (st: State<S, A>) => State<S, B>;
     /**
      * Sequences two State computations. The state output of the first is passed
      * as the state input to the second.
@@ -2483,7 +2108,7 @@ declare namespace State {
      * State.evaluate([])(program); // ["a", "b"]
      * ```
      */
-    const chain: <S, A, B>(f: (a: A) => State<S, B>) => (st: State<S, A>) => State<S, B>;
+    chain: <S, A, B>(f: (a: A) => State<S, B>) => (st: State<S, A>) => State<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
@@ -2501,7 +2126,7 @@ declare namespace State {
      * State.evaluate(3)(program); // 6 + 3 = 9
      * ```
      */
-    const ap: <S, A>(arg: State<S, A>) => <B>(fn: State<S, (a: A) => B>) => State<S, B>;
+    ap: <S, A>(arg: State<S, A>) => <B>(fn: State<S, (a: A) => B>) => State<S, B>;
     /**
      * Runs a side effect on the produced value without changing the State computation.
      *
@@ -2514,7 +2139,7 @@ declare namespace State {
      * );
      * ```
      */
-    const tap: <S, A>(f: (a: A) => void) => (st: State<S, A>) => State<S, A>;
+    tap: <S, A>(f: (a: A) => void) => (st: State<S, A>) => State<S, A>;
     /**
      * Runs a State computation with an initial state, returning both the
      * produced value and the final state as a pair.
@@ -2531,7 +2156,7 @@ declare namespace State {
      * State.run(0)(program); // [1, 1]
      * ```
      */
-    const run: <S>(initialState: S) => <A>(st: State<S, A>) => readonly [A, S];
+    run: <S>(initialState: S) => <A>(st: State<S, A>) => readonly [A, S];
     /**
      * Runs a State computation with an initial state, returning only the
      * produced value (discarding the final state).
@@ -2544,7 +2169,7 @@ declare namespace State {
      * )); // ["x"]
      * ```
      */
-    const evaluate: <S>(initialState: S) => <A>(st: State<S, A>) => A;
+    evaluate: <S>(initialState: S) => <A>(st: State<S, A>) => A;
     /**
      * Runs a State computation with an initial state, returning only the
      * final state (discarding the produced value).
@@ -2557,7 +2182,7 @@ declare namespace State {
      * )); // 20
      * ```
      */
-    const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
+    execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
     /**
      * Lifts a State value into an accumulator object.
      *
@@ -2566,7 +2191,7 @@ declare namespace State {
      * pipe(State.resolve(42), State.bindTo("value")); // State({ value: 42 })
      * ```
      */
-    const bindTo: <K extends string>(key: K) => <S, A>(data: State<S, A>) => State<S, { [P in K]: A; }>;
+    bindTo: <K extends string>(key: K) => <S, A>(data: State<S, A>) => State<S, { [P in K]: A; }>;
     /**
      * Evaluates a new State using the current accumulator and attaches the output to a new key.
      *
@@ -2578,7 +2203,7 @@ declare namespace State {
      * ); // State({ a: 1, b: 2 })
      * ```
      */
-    const bind: <K extends string, S, A, B>(key: K, f: (a: A) => State<S, B>) => (data: State<S, A>) => State<S, A & { [P in K]: B; }>;
+    bind: <K extends string, S, A, B>(key: K, f: (a: A) => State<S, B>) => (data: State<S, A>) => State<S, A & { [P in K]: B; }>;
     /**
      * Focuses a State computation on a sub-state using a Lens.
      *
@@ -2590,8 +2215,8 @@ declare namespace State {
      * const focusedProgram = pipe(increment, State.focus(countLens));
      * ```
      */
-    const focus: <S, A>(lens: Lens<S, A>) => <B>(stateOp: State<A, B>) => State<S, B>;
-}
+    focus: <S, A>(lens: Lens<S, A>) => <B>(stateOp: State<A, B>) => State<S, B>;
+};
 
 /**
  * An event stream pipeline for a typed message schema `S`.
@@ -2644,63 +2269,7 @@ type Stream<S extends Record<string, unknown>> = {
     /** @internal */
     _isEmitting: boolean;
 };
-declare namespace Stream {
-    /**
-     * Message payload emitted across a Stream.
-     */
-    type Message<S extends Record<string, unknown>> = {
-        [K in keyof S & string]: WithKind<K> & WithValue<S[K]>;
-    }[keyof S & string];
-    /**
-     * Options for constructing a `Stream` instance.
-     */
-    type Options = {
-        readonly name?: string;
-        readonly onError?: (error: unknown) => void;
-    };
-    /**
-     * Options for sequence matching and listener execution.
-     */
-    type SequenceOptions<S extends Record<string, unknown>> = {
-        /** Match events in exact array sequence order (default: false). */
-        readonly ordered?: boolean;
-        /** Match sequence strictly consecutively without intermediary events (default: false). */
-        readonly strict?: boolean;
-        /** Automatically unsubscribe after the first match/cycle completes (default: false). */
-        readonly once?: boolean;
-        /** Event kind(s) that reset sequence tracking to index 0. */
-        readonly reset?: (keyof S & string) | ReadonlyArray<keyof S & string>;
-        /** Event kind(s) in the sequence that may be present or skipped. */
-        readonly optional?: (keyof S & string) | ReadonlyArray<keyof S & string>;
-    };
-    /**
-     * Handle for an active stateful subscription.
-     */
-    type Subscription<State> = {
-        readonly unsubscribe: () => void;
-        readonly getState: () => State;
-    };
-    /**
-     * Options for structural stream forwarding.
-     */
-    type ForwardOptions<S extends Record<string, unknown>> = {
-        readonly from: Stream<S>;
-        readonly to: Stream<S> | ReadonlyArray<Stream<S>>;
-        readonly only?: ReadonlyArray<keyof S & string>;
-    };
-    /**
-     * Builder handle returned by `Stream.listen`.
-     */
-    type ListenerBuilder<S extends Record<string, unknown>> = {
-        /**
-         * Stateful reduction over events/sequences.
-         */
-        readonly reduce: <State>(reducer: (msg: Message<S>, state: State) => State, initialState: State) => Subscription<State>;
-        /**
-         * Stateless side-effect execution.
-         */
-        readonly tap: (effect: (msg: Message<S>) => void) => () => void;
-    };
+declare const Stream: {
     /**
      * Constructs a new `Stream` instance.
      *
@@ -2709,7 +2278,7 @@ declare namespace Stream {
      * const stream = Stream.make<AppMessages>({ name: "app" });
      * ```
      */
-    const make: <S extends Record<string, unknown>>(options?: Options) => Stream<S>;
+    make: <S extends Record<string, unknown>>(options?: Stream.Options) => Stream<S>;
     /**
      * Emits a message payload to one or more target streams.
      *
@@ -2728,7 +2297,7 @@ declare namespace Stream {
      * });
      * ```
      */
-    const emit: <S extends Record<string, unknown>, K extends keyof S & string>(target: Stream<S> | ReadonlyArray<Stream<S>>, message: WithKind<K> & WithValue<S[K]>) => void;
+    emit: <S extends Record<string, unknown>, K extends keyof S & string>(target: Stream<S> | ReadonlyArray<Stream<S>>, message: WithKind<K> & WithValue<S[K]>) => void;
     /**
      * Forwards messages from one stream to another (or multiple).
      *
@@ -2741,7 +2310,7 @@ declare namespace Stream {
      * });
      * ```
      */
-    const forward: <S extends Record<string, unknown>>(options: ForwardOptions<S>) => () => void;
+    forward: <S extends Record<string, unknown>>(options: Stream.ForwardOptions<S>) => () => void;
     /**
      * Initiates listener registration on a stream for specific event kind(s) or sequence.
      *
@@ -2757,7 +2326,36 @@ declare namespace Stream {
      * );
      * ```
      */
-    const listen: <S extends Record<string, unknown>, K extends keyof S & string>(stream: Stream<S>, events: K | ReadonlyArray<K>, options?: SequenceOptions<S>) => ListenerBuilder<S>;
+    listen: <S extends Record<string, unknown>, K extends keyof S & string>(stream: Stream<S>, events: K | ReadonlyArray<K>, options?: Stream.SequenceOptions<S>) => Stream.ListenerBuilder<S>;
+};
+declare namespace Stream {
+    type Message<S extends Record<string, unknown>> = {
+        [K in keyof S & string]: WithKind<K> & WithValue<S[K]>;
+    }[keyof S & string];
+    type Options = {
+        readonly name?: string;
+        readonly onError?: (error: unknown) => void;
+    };
+    type SequenceOptions<S extends Record<string, unknown>> = {
+        readonly ordered?: boolean;
+        readonly strict?: boolean;
+        readonly once?: boolean;
+        readonly reset?: (keyof S & string) | ReadonlyArray<keyof S & string>;
+        readonly optional?: (keyof S & string) | ReadonlyArray<keyof S & string>;
+    };
+    type Subscription<State> = {
+        readonly unsubscribe: () => void;
+        readonly getState: () => State;
+    };
+    type ForwardOptions<S extends Record<string, unknown>> = {
+        readonly from: Stream<S>;
+        readonly to: Stream<S> | ReadonlyArray<Stream<S>>;
+        readonly only?: ReadonlyArray<keyof S & string>;
+    };
+    type ListenerBuilder<S extends Record<string, unknown>> = {
+        readonly reduce: <State>(reducer: (msg: Message<S>, state: State) => State, initialState: State) => Subscription<State>;
+        readonly tap: (effect: (msg: Message<S>) => void) => () => void;
+    };
 }
 
 type TheseFirst<T> = WithKind<"First"> & WithFirst<T>;
@@ -2787,8 +2385,8 @@ type TheseBoth<First, Second> = WithKind<"Both"> & WithFirst<First> & WithSecond
  * ```
  */
 type These<A, B> = TheseFirst<A> | TheseSecond<B> | TheseBoth<A, B>;
-declare namespace These {
-    namespace make {
+declare const These: {
+    make: {
         /**
          * Creates a These holding only a first value.
          *
@@ -2797,7 +2395,7 @@ declare namespace These {
          * These.make.first(42); // { kind: "First", first: 42 }
          * ```
          */
-        const first: <A>(value: A) => TheseFirst<A>;
+        first: <A>(value: A) => TheseFirst<A>;
         /**
          * Creates a These holding only a second value.
          *
@@ -2806,7 +2404,7 @@ declare namespace These {
          * These.make.second("warning"); // { kind: "Second", second: "warning" }
          * ```
          */
-        const second: <B>(value: B) => TheseSecond<B>;
+        second: <B>(value: B) => TheseSecond<B>;
         /**
          * Creates a These holding both a first and a second value simultaneously.
          *
@@ -2815,9 +2413,9 @@ declare namespace These {
          * These.make.both(42, "Deprecated API used"); // { kind: "Both", first: 42, second: "Deprecated API used" }
          * ```
          */
-        const both: <A, B>(f: A, s: B) => TheseBoth<A, B>;
-    }
-    namespace is {
+        both: <A, B>(f: A, s: B) => TheseBoth<A, B>;
+    };
+    is: {
         /**
          * Type guard — checks if a These holds only a first value.
          *
@@ -2829,7 +2427,7 @@ declare namespace These {
          * }
          * ```
          */
-        const first: <A, B>(data: These<A, B>) => data is TheseFirst<A>;
+        first: <A, B>(data: These<A, B>) => data is TheseFirst<A>;
         /**
          * Type guard — checks if a These holds only a second value.
          *
@@ -2841,7 +2439,7 @@ declare namespace These {
          * }
          * ```
          */
-        const second: <A, B>(data: These<A, B>) => data is TheseSecond<B>;
+        second: <A, B>(data: These<A, B>) => data is TheseSecond<B>;
         /**
          * Type guard — checks if a These holds both values simultaneously.
          *
@@ -2853,8 +2451,8 @@ declare namespace These {
          * }
          * ```
          */
-        const both: <A, B>(data: These<A, B>) => data is TheseBoth<A, B>;
-    }
+        both: <A, B>(data: These<A, B>) => data is TheseBoth<A, B>;
+    };
     /**
      * Returns true if the These contains a first value (First or Both).
      *
@@ -2865,7 +2463,7 @@ declare namespace These {
      * These.hasFirst(These.make.second("warn"));  // false
      * ```
      */
-    const hasFirst: <A, B>(data: These<A, B>) => data is TheseFirst<A> | TheseBoth<A, B>;
+    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).
      *
@@ -2876,7 +2474,7 @@ declare namespace These {
      * These.hasSecond(These.make.first(42));       // false
      * ```
      */
-    const hasSecond: <A, B>(data: These<A, B>) => data is TheseSecond<B> | TheseBoth<A, B>;
+    hasSecond: <A, B>(data: These<A, B>) => data is TheseSecond<B> | TheseBoth<A, B>;
     /**
      * Transforms the first value, leaving the second unchanged.
      *
@@ -2887,7 +2485,7 @@ declare namespace These {
      * pipe(These.make.second("warn"), These.mapFirst(n => n * 2));     // Second("warn")
      * ```
      */
-    const mapFirst: <A, C>(f: (a: A) => C) => <B>(data: These<A, B>) => These<C, B>;
+    mapFirst: <A, C>(f: (a: A) => C) => <B>(data: These<A, B>) => These<C, B>;
     /**
      * Transforms the second value, leaving the first unchanged.
      *
@@ -2897,7 +2495,7 @@ declare namespace These {
      * pipe(These.make.both(5, "warn"), These.mapSecond(e => e.toUpperCase()));    // Both(5, "WARN")
      * ```
      */
-    const mapSecond: <B, D>(f: (b: B) => D) => <A>(data: These<A, B>) => These<A, D>;
+    mapSecond: <B, D>(f: (b: B) => D) => <A>(data: These<A, B>) => These<A, D>;
     /**
      * Transforms both the first and second values independently.
      *
@@ -2909,7 +2507,7 @@ declare namespace These {
      * ); // Both(10, "WARN")
      * ```
      */
-    const mapBoth: <A, C, B, D>(onFirst: (a: A) => C, onSecond: (b: B) => D) => (data: These<A, B>) => These<C, D>;
+    mapBoth: <A, C, B, D>(onFirst: (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.
@@ -2923,7 +2521,7 @@ declare namespace These {
      * pipe(These.make.second("warn"), These.chainFirst(double));      // Second("warn")
      * ```
      */
-    const chainFirst: <A, B, C>(f: (a: A) => These<C, B>) => (data: These<A, B>) => These<C, B>;
+    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.
@@ -2937,7 +2535,7 @@ declare namespace These {
      * pipe(These.make.first(5), These.chainSecond(shout));            // First(5)
      * ```
      */
-    const chainSecond: <A, B, D>(f: (b: B) => These<A, D>) => (data: These<A, B>) => These<A, D>;
+    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.
      *
@@ -2953,7 +2551,7 @@ declare namespace These {
      * );
      * ```
      */
-    const fold: <A, B, C>(onFirst: (a: A) => C, onSecond: (b: B) => C, onBoth: (a: A, b: B) => C) => (data: These<A, B>) => C;
+    fold: <A, B, C>(onFirst: (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.
      *
@@ -2969,7 +2567,7 @@ declare namespace These {
      * );
      * ```
      */
-    const match: <A, B, C>(cases: {
+    match: <A, B, C>(cases: {
         first: (a: A) => C;
         second: (b: B) => C;
         both: (a: A, b: B) => C;
@@ -2986,7 +2584,7 @@ declare namespace These {
      * pipe(These.make.second("warn"), These.getFirstOrElse(() => null));   // null — typed as number | null
      * ```
      */
-    const getFirstOrElse: <A, C>(defaultValue: () => C) => <B>(data: These<A, B>) => A | C;
+    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`.
@@ -2999,7 +2597,7 @@ declare namespace These {
      * pipe(These.make.first(5), These.getSecondOrElse(() => null));         // null — typed as string | null
      * ```
      */
-    const getSecondOrElse: <B, D>(defaultValue: () => D) => <A>(data: These<A, B>) => B | D;
+    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.
@@ -3009,7 +2607,7 @@ declare namespace These {
      * pipe(These.make.first(5), These.tap(console.log)); // logs 5, returns First(5)
      * ```
      */
-    const tap: <A>(f: (a: A) => void) => <B>(data: These<A, B>) => These<A, B>;
+    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)
@@ -3023,7 +2621,7 @@ declare namespace These {
      * These.swap(These.make.both(5, "warn"));     // Both("warn", 5)
      * ```
      */
-    const swap: <A, B>(data: These<A, B>) => These<B, A>;
-}
+    swap: <A, B>(data: These<A, B>) => These<B, A>;
+};
 
 export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Pair, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond };