@nlozgachev/pipelined 0.65.0 → 0.66.0

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

@@ -218,6 +218,145 @@ declare const Equality: {
   tuple: <T extends readonly unknown[]>(...equalities: { [K in keyof T]: Equality<T[K]>; }) => Equality<T>;
 };
 //#endregion
+//#region src/Core/EventBus.d.ts
+/**
+ * An event bus pipeline for a typed message schema `S`.
+ *
+ * `EventBus` provides typed event emission, sequence matching, state reduction,
+ * and structural event bus forwarding.
+ *
+ * @example
+ * ```ts
+ * type AppMessages = {
+ *   userLoggedIn: { userId: string };
+ *   checkoutStarted: { amount: number };
+ * };
+ *
+ * const appBus = EventBus.make<AppMessages>();
+ *
+ * const subscription = EventBus.listen(
+ *   appBus,
+ *   ["userLoggedIn", "checkoutStarted"],
+ *   { ordered: true }
+ * ).reduce(
+ *   (msg, state) => {
+ *     if (msg.kind === "checkoutStarted") {
+ *       return { count: state.count + 1 };
+ *     }
+ *     return state;
+ *   },
+ *   { count: 0 }
+ * );
+ *
+ * EventBus.emit(appBus, {
+ *   kind: "userLoggedIn",
+ *   value: { userId: "user-1" },
+ * });
+ * ```
+ */
+type EventBus<S extends Record<string, unknown>> = {
+  readonly options?: EventBus.Options;
+  /** @internal */
+  readonly _listeners: Set<(msg: EventBus.Message<S>) => void>;
+  /**
+   * @internal
+   * Lazy array snapshot of `_listeners`. Avoids allocating new array objects on every `emit` call
+   * (2.98x emission speedup, 0 heap allocations). Rebuilt whenever `_listeners` is mutated,
+   * guaranteeing reentrancy safety and preventing listeners subscribed mid-emission from executing early.
+   */
+  _listenerArray: Array<(msg: EventBus.Message<S>) => void> | null;
+  /** @internal */
+  readonly _queue: Array<EventBus.Message<S>>;
+  /** @internal */
+  _isEmitting: boolean;
+};
+declare const EventBus: {
+  /**
+   * Constructs a new `EventBus` instance.
+   *
+   * @example
+   * ```ts
+   * const bus = EventBus.make<AppMessages>({ name: "app" });
+   * ```
+   */
+  make: <S extends Record<string, unknown>>(options?: EventBus.Options) => EventBus<S>;
+  /**
+   * Emits a message payload to one or more target event buses.
+   *
+   * Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
+   *
+   * @example
+   * ```ts
+   * EventBus.emit(busA, {
+   *   kind: "userLoggedIn",
+   *   value: { userId: "user-1" },
+   * });
+   *
+   * EventBus.emit([busA, busB], {
+   *   kind: "userLoggedIn",
+   *   value: { userId: "user-1" },
+   * });
+   * ```
+   */
+  emit: <S extends Record<string, unknown>, K extends keyof S & string>(target: EventBus<S> | ReadonlyArray<EventBus<S>>, message: WithKind<K> & WithValue<S[K]>) => void;
+  /**
+   * Forwards messages from one event bus to another (or multiple).
+   *
+   * @example
+   * ```ts
+   * const stop = EventBus.forward({
+   *   from: authBus,
+   *   to: analyticsBus,
+   *   only: ["userLoggedIn"],
+   * });
+   * ```
+   */
+  forward: <S extends Record<string, unknown>>(options: EventBus.ForwardOptions<S>) => () => void;
+  /**
+   * Initiates listener registration on an event bus for specific event kind(s) or sequence.
+   *
+   * @example
+   * ```ts
+   * const sub = EventBus.listen(
+   *   appBus,
+   *   ["userLoggedIn", "checkoutStarted"],
+   *   { ordered: true }
+   * ).reduce(
+   *   (msg, state) => ({ count: state.count + 1 }),
+   *   { count: 0 }
+   * );
+   * ```
+   */
+  listen: <S extends Record<string, unknown>, K extends keyof S & string>(bus: EventBus<S>, events: K | ReadonlyArray<K>, options?: EventBus.SequenceOptions<S>) => EventBus.ListenerBuilder<S>;
+};
+declare namespace EventBus {
+  type Message<S extends Record<string, unknown>> = { [K in keyof S & string]: WithKind<K> & WithValue<S[K]>; }[keyof S & string];
+  type Options = {
+    readonly name?: string;
+    readonly onError?: (error: unknown) => void;
+  };
+  type SequenceOptions<S extends Record<string, unknown>> = {
+    readonly ordered?: boolean;
+    readonly strict?: boolean;
+    readonly once?: boolean;
+    readonly reset?: (keyof S & string) | ReadonlyArray<keyof S & string>;
+    readonly optional?: (keyof S & string) | ReadonlyArray<keyof S & string>;
+  };
+  type Subscription<State> = {
+    readonly unsubscribe: () => void;
+    readonly getState: () => State;
+  };
+  type ForwardOptions<S extends Record<string, unknown>> = {
+    readonly from: EventBus<S>;
+    readonly to: EventBus<S> | ReadonlyArray<EventBus<S>>;
+    readonly only?: ReadonlyArray<keyof S & string>;
+  };
+  type ListenerBuilder<S extends Record<string, unknown>> = {
+    readonly reduce: <State>(reducer: (msg: Message<S>, state: State) => State, initialState: State) => Subscription<State>;
+    readonly tap: (effect: (msg: Message<S>) => void) => () => void;
+  };
+}
+//#endregion
 //#region src/Core/Lazy.d.ts
 /**
  * A synchronous memoized computation. The factory function runs exactly once —
@@ -712,6 +851,18 @@ declare const Maybe: {
      */
     Result: <E, A>(data: Result<E, A>) => Maybe<A>;
   };
+  /**
+   * Wraps a synchronous operation that may throw, returning a `Maybe<A>`.
+   * Returns `Some(value)` if successful, or `None` if an exception is thrown.
+   *
+   * @example
+   * ```ts
+   * const safeParse = (s: string) => Maybe.tryCatch(() => JSON.parse(s));
+   * safeParse('{"a": 1}'); // Some({ a: 1 })
+   * safeParse('invalid');   // None
+   * ```
+   */
+  tryCatch: <A>(f: () => A) => Maybe<A>;
   /**
    * Transforms the value inside a Maybe if it exists.
    *
@@ -799,16 +950,32 @@ declare const Maybe: {
    */
   tap: <A>(f: (a: A) => void) => (data: Maybe<A>) => Maybe<A>;
   /**
-   * Filters a Maybe based on a predicate.
+   * Executes a side effect when the Maybe is None, without changing the Maybe.
+   *
+   * @example
+   * ```ts
+   * pipe(
+   *   Maybe.make.none(),
+   *   Maybe.tapNone(() => console.log("Value missing")),
+   * );
+   * ```
+   */
+  tapNone: (f: () => void) => <A>(data: Maybe<A>) => Maybe<A>;
+  /**
+   * Filters a Maybe based on a predicate or type guard.
    * Returns None if the predicate returns false or if the Maybe is already None.
    *
    * @example
    * ```ts
    * pipe(Maybe.make.some(5), Maybe.filter(n => n > 3)); // Some(5)
    * pipe(Maybe.make.some(2), Maybe.filter(n => n > 3)); // None
+   * pipe(Maybe.make.some("hi"), Maybe.filter((x): x is string => typeof x === "string")); // Some("hi")
    * ```
    */
-  filter: <A>(predicate: (a: A) => boolean) => (data: Maybe<A>) => Maybe<A>;
+  filter: {
+    <A, B extends A>(refinement: (a: A) => a is B): (data: Maybe<A>) => Maybe<B>;
+    <A>(predicate: (a: A) => boolean): (data: Maybe<A>) => Maybe<A>;
+  };
   /**
    * Recovers from a None by providing a fallback Maybe.
    * The fallback can produce a different type, widening the result to `Maybe<A | B>`.
@@ -3118,145 +3285,6 @@ declare const State$1: {
   focus: <S, A>(lens: Lens<S, A>) => <B>(stateOp: State$1<A, B>) => State$1<S, B>;
 };
 //#endregion
-//#region src/Core/Stream.d.ts
-/**
- * An event stream pipeline for a typed message schema `S`.
- *
- * `Stream` provides typed event emission, sequence matching, state reduction,
- * and structural stream forwarding.
- *
- * @example
- * ```ts
- * type AppMessages = {
- *   userLoggedIn: { userId: string };
- *   checkoutStarted: { amount: number };
- * };
- *
- * const appStream = Stream.make<AppMessages>();
- *
- * const subscription = Stream.listen(
- *   appStream,
- *   ["userLoggedIn", "checkoutStarted"],
- *   { ordered: true }
- * ).reduce(
- *   (msg, state) => {
- *     if (msg.kind === "checkoutStarted") {
- *       return { count: state.count + 1 };
- *     }
- *     return state;
- *   },
- *   { count: 0 }
- * );
- *
- * Stream.emit(appStream, {
- *   kind: "userLoggedIn",
- *   value: { userId: "user-1" },
- * });
- * ```
- */
-type Stream<S extends Record<string, unknown>> = {
-  readonly options?: Stream.Options;
-  /** @internal */
-  readonly _listeners: Set<(msg: Stream.Message<S>) => void>;
-  /**
-   * @internal
-   * Lazy array snapshot of `_listeners`. Avoids allocating new array objects on every `emit` call
-   * (2.98x emission speedup, 0 heap allocations). Rebuilt whenever `_listeners` is mutated,
-   * guaranteeing reentrancy safety and preventing listeners subscribed mid-emission from executing early.
-   */
-  _listenerArray: Array<(msg: Stream.Message<S>) => void> | null;
-  /** @internal */
-  readonly _queue: Array<Stream.Message<S>>;
-  /** @internal */
-  _isEmitting: boolean;
-};
-declare const Stream: {
-  /**
-   * Constructs a new `Stream` instance.
-   *
-   * @example
-   * ```ts
-   * const stream = Stream.make<AppMessages>({ name: "app" });
-   * ```
-   */
-  make: <S extends Record<string, unknown>>(options?: Stream.Options) => Stream<S>;
-  /**
-   * Emits a message payload to one or more target streams.
-   *
-   * Uses a synchronous breadth-first trampoline queue to handle re-entrant emissions deterministically.
-   *
-   * @example
-   * ```ts
-   * Stream.emit(streamA, {
-   *   kind: "userLoggedIn",
-   *   value: { userId: "user-1" },
-   * });
-   *
-   * Stream.emit([streamA, streamB], {
-   *   kind: "userLoggedIn",
-   *   value: { userId: "user-1" },
-   * });
-   * ```
-   */
-  emit: <S extends Record<string, unknown>, K extends keyof S & string>(target: Stream<S> | ReadonlyArray<Stream<S>>, message: WithKind<K> & WithValue<S[K]>) => void;
-  /**
-   * Forwards messages from one stream to another (or multiple).
-   *
-   * @example
-   * ```ts
-   * const stop = Stream.forward({
-   *   from: authStream,
-   *   to: analyticsStream,
-   *   only: ["userLoggedIn"],
-   * });
-   * ```
-   */
-  forward: <S extends Record<string, unknown>>(options: Stream.ForwardOptions<S>) => () => void;
-  /**
-   * Initiates listener registration on a stream for specific event kind(s) or sequence.
-   *
-   * @example
-   * ```ts
-   * const sub = Stream.listen(
-   *   appStream,
-   *   ["userLoggedIn", "checkoutStarted"],
-   *   { ordered: true }
-   * ).reduce(
-   *   (msg, state) => ({ count: state.count + 1 }),
-   *   { count: 0 }
-   * );
-   * ```
-   */
-  listen: <S extends Record<string, unknown>, K extends keyof S & string>(stream: Stream<S>, events: K | ReadonlyArray<K>, options?: Stream.SequenceOptions<S>) => Stream.ListenerBuilder<S>;
-};
-declare namespace Stream {
-  type Message<S extends Record<string, unknown>> = { [K in keyof S & string]: WithKind<K> & WithValue<S[K]>; }[keyof S & string];
-  type Options = {
-    readonly name?: string;
-    readonly onError?: (error: unknown) => void;
-  };
-  type SequenceOptions<S extends Record<string, unknown>> = {
-    readonly ordered?: boolean;
-    readonly strict?: boolean;
-    readonly once?: boolean;
-    readonly reset?: (keyof S & string) | ReadonlyArray<keyof S & string>;
-    readonly optional?: (keyof S & string) | ReadonlyArray<keyof S & string>;
-  };
-  type Subscription<State> = {
-    readonly unsubscribe: () => void;
-    readonly getState: () => State;
-  };
-  type ForwardOptions<S extends Record<string, unknown>> = {
-    readonly from: Stream<S>;
-    readonly to: Stream<S> | ReadonlyArray<Stream<S>>;
-    readonly only?: ReadonlyArray<keyof S & string>;
-  };
-  type ListenerBuilder<S extends Record<string, unknown>> = {
-    readonly reduce: <State>(reducer: (msg: Message<S>, state: State) => State, initialState: State) => Subscription<State>;
-    readonly tap: (effect: (msg: Message<S>) => void) => () => void;
-  };
-}
-//#endregion
 //#region src/Core/Validation.d.ts
 /**
  * Validation represents a value that is either passed with a success value,
@@ -3649,7 +3677,7 @@ declare const Validation: {
  *   return type using `Task.Result<E, A>` instead.
  *
  * An optional `AbortSignal` can be passed at the call site. Combinators like
- * `retry`, `pollUntil`, and `timeout` thread it automatically to every inner
+ * `retry`, `poll`, and `timeout` thread it automatically to every inner
  * operation. Existing tasks that ignore the signal continue to work unchanged.
  *
  * Calling a Task returns a `Deferred<A>` — a one-shot async value that supports
@@ -3781,14 +3809,19 @@ declare const Task: {
   tap: <A>(f: (a: A) => void) => (data: Task<A>) => Task<A>;
   /**
    * Runs multiple Tasks in parallel and collects their results.
+   * An optional `concurrency` option limits the number of tasks executing at any given time.
    *
    * @example
    * ```ts
    * Task.all([loadConfig, detectLocale, loadTheme])();
    * // Deferred<[Config, string, Theme]>
+   *
+   * Task.all([loadConfig, detectLocale, loadTheme], { concurrency: 2 })();
    * ```
    */
-  all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
+  all: <T extends readonly Task<unknown>[]>(tasks: T, options?: {
+    concurrency?: number;
+  }) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
   /**
    * Delays the execution of a Task by the specified duration.
    * Useful for debouncing or rate limiting.
@@ -3819,23 +3852,23 @@ declare const Task: {
     delay?: Duration;
   }) => <A>(task: Task<A>) => Task<readonly A[]>;
   /**
-   * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-   * An optional delay duration can be inserted between runs.
-   * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
+   * Polls a Task repeatedly until the result satisfies a predicate, returning that result.
+   * An optional delay duration can be inserted between polling runs.
+   * An optional `attempts` cap stops the loop after N calls — the last value is returned
    * regardless of whether the predicate was satisfied.
    *
    * @example
    * ```ts
    * pipe(
    *   checkStatus,
-   *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
+   *   Task.poll({ until: (s) => s === "ready", delay: Duration.milliseconds(500) })
    * )(); // polls every 500ms until status is "ready"
    * ```
    */
-  repeatUntil: <A>(options: {
-    when: (a: A) => boolean;
+  poll: <A>(options: {
+    until: (a: A) => boolean;
     delay?: Duration;
-    maxAttempts?: number;
+    attempts?: number;
   }) => (task: Task<A>) => Task<A>;
   /**
    * Resolves with the value of the first Task to complete. All Tasks start
@@ -4055,13 +4088,17 @@ declare const Task: {
     bindTo: <K extends string>(key: K) => <E, A>(data: Task.Result<E, A>) => Task.Result<E, { [P in K]: A; }>;
     bind: <K extends string, E, A, B>(key: K, f: (a: A) => Task.Result<E, B>) => (data: Task.Result<E, A>) => Task.Result<E, A & { [P in K]: B; }>;
     struct: <E, R extends Record<string, any>>(fields: { [K in keyof R]: Task.Result<E, R[K]>; }) => Task.Result<E, R>;
-    retry: (policy: RetryPolicy) => <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
+    retry: (policy: RetryPolicy, options?: {
+      when?: (error: unknown) => boolean;
+    }) => <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
     memoize: <E, A>(task: Task.Result<E, A>) => Task.Result<E, A>;
     timeout: <E2>(options: {
       duration: Duration;
       onTimeout: () => E2;
     }) => <E1 = never, A = unknown>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A>;
     allSettled: <E, A>(tasks: ReadonlyArray<Task.Result<E, A>>) => Task<ReadonlyArray<Result<E, A>>>;
+    ensure: <A, E2>(predicate: (a: A) => boolean, onFail: (a: A) => E2) => <E1 = never>(task: Task.Result<E1, A>) => Task.Result<E1 | E2, A>;
+    bimap: <E1, E2, A, B>(onErr: (e: E1) => E2, onOk: (a: A) => B) => (task: Task.Result<E1, A>) => Task.Result<E2, B>;
   };
   Validation: {
     make: {
@@ -4380,4 +4417,4 @@ declare const These: {
   swap: <A, B>(data: These<A, B>) => These<B, A>;
 };
 //#endregion
-export { Logged as A, Pair as C, Maybe as D, Op as E, Lazy as M, Equality as N, None as O, Combinable as P, Predicate as S, Optional as T, NotAsked as _, Task as a, Refinement as b, Validation as c, Err$1 as d, Ok$1 as f, Loading as g, Failure as h, TheseSecond as i, Lens as j, Some as k, Stream as l, Resource as m, TheseBoth as n, Failed as o, Result as p, TheseFirst as r, Passed as s, These as t, State$1 as u, RemoteData as v, Ordering as w, Reader as x, Success as y };
+export { Lens as A, Ordering as C, None as D, Maybe as E, EventBus as M, Equality as N, Some as O, Combinable as P, Pair as S, Op as T, RemoteData as _, Task as a, Reader as b, Validation as c, Ok$1 as d, Result as f, NotAsked as g, Loading as h, TheseSecond as i, Lazy as j, Logged as k, State$1 as l, Failure as m, TheseBoth as n, Failed as o, Resource as p, TheseFirst as r, Passed as s, These as t, Err$1 as u, Success as v, Optional as w, Predicate as x, Refinement as y };