@nlozgachev/pipelined 0.48.0 → 0.50.0

package/README.md

@@ -18,11 +18,12 @@ In mainstream TypeScript, code is often burdened by implicit control flow: unche
 manual null propagation, and unhandled asynchronous failures. `pipelined` turns these complex
 runtime states into simple, transparent data structures that compose. By representing optionality as
 `Maybe`, failures as `Result`, lazy asynchronous pipelines as `Task.Result`, and repeated stateful
-interactions as `Op`, the library helps disentangle business logic from control mechanics.
+interactions as `Op` and `Stream`, the library helps disentangle business logic from control
+mechanics.
 
 To support these patterns without introducing bloat, the library is designed to be lightweight,
-zero-dependency, and fully tree-shakeable. The core module (`/core`) is under 14 KB gzipped, and the
-entire toolkit is under 21 KB gzipped, making it equally suitable for client and server
+zero-dependency, and fully tree-shakeable. The core module (`/core`) is under 16 KB gzipped, and the
+entire toolkit is under 25 KB gzipped, making it equally suitable for client and server
 environments.
 
 ## Documentation
@@ -303,6 +304,57 @@ The system supports a variety of built-in strategies — `restartable`, `exclusi
 `throttled`, `queue`, `buffered`, `concurrent`, `keyed`, and `once` — making the integration of
 complex async scenarios highly predictable.
 
+## Example: typed event streaming and sequence reduction
+
+Decoupling event producers from stateful event consumers often leads to untyped event emitters or
+complex ad-hoc state machines. `Stream` models event pipelines with typed message schemas, sequence
+pattern matching, and state reduction:
+
+```ts
+import { Stream } from "@nlozgachev/pipelined/core";
+
+type UserFlowMessages = {
+  sessionStarted: { sessionId: string };
+  stepCompleted: { stepName: string };
+  flowFinished: { totalTimeMs: number };
+};
+
+const flowStream = Stream.make<UserFlowMessages>();
+
+// Match sequence: sessionStarted -> stepCompleted -> flowFinished
+const sub = Stream.listen(
+  flowStream,
+  ["sessionStarted", "stepCompleted", "flowFinished"],
+  { ordered: true },
+).reduce(
+  (msg, state) => {
+    if (msg.kind === "flowFinished") {
+      return { completedFlows: state.completedFlows + 1 };
+    }
+    return state;
+  },
+  { completedFlows: 0 },
+);
+
+// Emit typed messages to the stream
+Stream.emit(flowStream, {
+  kind: "sessionStarted",
+  value: { sessionId: "sess-101" },
+});
+
+Stream.emit(flowStream, {
+  kind: "stepCompleted",
+  value: { stepName: "onboarding" },
+});
+
+Stream.emit(flowStream, {
+  kind: "flowFinished",
+  value: { totalTimeMs: 4200 },
+});
+
+sub.getState(); // { completedFlows: 1 }
+```
+
 ## What is included
 
 The library covers the full spectrum of state and control flow scenarios encountered in production
@@ -322,8 +374,9 @@ provides a strongly-typed, immutable two-element pair.
 handled by `Task.Result`, `Task.Maybe`, and `Task.Validation`. For managing stateful, recurring
 asynchronous operations with complex scheduling, `Op` implements named concurrency strategies such
 as `restartable`, `exclusive`, `debounced`, `throttled`, and `queue`, handling retries, timeouts,
-and signal propagation automatically. `Deferred` represents a lightweight, infallible asynchronous
-value that is guaranteed to always resolve without rejection.
+and signal propagation automatically. `Stream` provides typed event streaming, sequence pattern
+matching, state reduction, and structural forwarding across channels. `Deferred` represents a
+lightweight, infallible asynchronous value that is guaranteed to always resolve without rejection.
 
 ### Optics and environment state
 

package/dist/{chunk-UGVU2RTM.mjs → chunk-6N27QZFK.mjs}

@@ -4,7 +4,7 @@ import {
   Result,
   Task,
   isNonEmptyArr
-} from "./chunk-LR63GW6J.mjs";
+} from "./chunk-U64ASY7P.mjs";
 
 // src/Data/Arr.ts
 var ArrMaybe;

package/dist/{chunk-LR63GW6J.mjs → chunk-U64ASY7P.mjs}

@@ -1732,6 +1732,136 @@ var State;
   };
 })(State || (State = {}));
 
+// src/Core/Stream.ts
+var Stream;
+((Stream2) => {
+  Stream2.make = (options) => ({
+    options,
+    _listeners: /* @__PURE__ */ new Set(),
+    _queue: [],
+    _isEmitting: false
+  });
+  Stream2.emit = (target, message) => {
+    const targets = Array.isArray(target) ? target : [target];
+    const msg = message;
+    for (const stream of targets) {
+      stream._queue.push(msg);
+      if (!stream._isEmitting) {
+        stream._isEmitting = true;
+        try {
+          while (stream._queue.length > 0) {
+            const nextMsg = stream._queue.shift();
+            const listeners = Array.from(stream._listeners);
+            for (const listener of listeners) {
+              try {
+                listener(nextMsg);
+              } catch (err2) {
+                if (stream.options?.onError) {
+                  stream.options.onError(err2);
+                } else {
+                  throw err2;
+                }
+              }
+            }
+          }
+        } finally {
+          stream._isEmitting = false;
+        }
+      }
+    }
+  };
+  Stream2.forward = (options) => {
+    const targets = Array.isArray(options.to) ? options.to : [options.to];
+    const filterSet = options.only ? new Set(options.only) : null;
+    const handler = (msg) => {
+      if (filterSet !== null && !filterSet.has(msg.kind)) {
+        return;
+      }
+      for (const target of targets) {
+        (0, Stream2.emit)(target, msg);
+      }
+    };
+    options.from._listeners.add(handler);
+    return () => {
+      options.from._listeners.delete(handler);
+    };
+  };
+  Stream2.listen = (stream, events, options) => {
+    const eventList = Array.isArray(events) ? events : [events];
+    const isOrdered = options?.ordered ?? false;
+    const isStrict = options?.strict ?? false;
+    const isOnce = options?.once ?? false;
+    const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+    const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
+    const createMatcher = (onMatch) => {
+      let sequenceIndex = 0;
+      return (msg) => {
+        if (resetKinds !== null && resetKinds.has(msg.kind)) {
+          sequenceIndex = 0;
+          return;
+        }
+        if (!isOrdered) {
+          if (eventList.includes(msg.kind)) {
+            onMatch(msg);
+          }
+          return;
+        }
+        let expectedKind = eventList[sequenceIndex];
+        if (expectedKind !== msg.kind && optionalKinds !== null) {
+          let lookaheadIndex = sequenceIndex;
+          while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) {
+            lookaheadIndex++;
+          }
+          if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
+            sequenceIndex = lookaheadIndex;
+            expectedKind = eventList[sequenceIndex];
+          }
+        }
+        if (msg.kind === expectedKind) {
+          sequenceIndex++;
+          if (sequenceIndex === eventList.length) {
+            sequenceIndex = 0;
+            onMatch(msg);
+          }
+        } else if (isStrict) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        } else if (eventList.includes(msg.kind)) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        }
+      };
+    };
+    return {
+      reduce: (reducer, initialState) => {
+        let currentState = initialState;
+        const listenerFn = createMatcher((msg) => {
+          currentState = reducer(msg, currentState);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return { unsubscribe, getState: () => currentState };
+      },
+      tap: (effect) => {
+        const listenerFn = createMatcher((msg) => {
+          effect(msg);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return unsubscribe;
+      }
+    };
+  };
+})(Stream || (Stream = {}));
+
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
@@ -2478,6 +2608,7 @@ export {
   Resource,
   Result,
   State,
+  Stream,
   TaskMaybe,
   TaskResult,
   isNonEmptyArr,

package/dist/core.d.mts

@@ -2451,6 +2451,166 @@ declare namespace State {
     const 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`.
+ *
+ * `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 */
+    readonly _queue: Array<Stream.Message<S>>;
+    /** @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;
+    };
+    /**
+     * Constructs a new `Stream` instance.
+     *
+     * @example
+     * ```ts
+     * const stream = Stream.make<AppMessages>({ name: "app" });
+     * ```
+     */
+    const make: <S extends Record<string, unknown>>(options?: 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" },
+     * });
+     * ```
+     */
+    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;
+    /**
+     * Forwards messages from one stream to another (or multiple).
+     *
+     * @example
+     * ```ts
+     * const stop = Stream.forward({
+     *   from: authStream,
+     *   to: analyticsStream,
+     *   only: ["userLoggedIn"],
+     * });
+     * ```
+     */
+    const forward: <S extends Record<string, unknown>>(options: 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 }
+     * );
+     * ```
+     */
+    const listen: <S extends Record<string, unknown>, K extends keyof S & string>(stream: Stream<S>, events: K | ReadonlyArray<K>, options?: SequenceOptions<S>) => ListenerBuilder<S>;
+}
+
 type TheseFirst<T> = WithKind<"First"> & WithFirst<T>;
 type TheseSecond<T> = WithKind<"Second"> & WithSecond<T>;
 type TheseBoth<First, Second> = WithKind<"Both"> & WithFirst<First> & WithSecond<Second>;
@@ -2859,4 +3019,4 @@ declare namespace Tuple {
     const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
 }
 
-export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };
+export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };

package/dist/core.d.ts

@@ -2451,6 +2451,166 @@ declare namespace State {
     const 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`.
+ *
+ * `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 */
+    readonly _queue: Array<Stream.Message<S>>;
+    /** @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;
+    };
+    /**
+     * Constructs a new `Stream` instance.
+     *
+     * @example
+     * ```ts
+     * const stream = Stream.make<AppMessages>({ name: "app" });
+     * ```
+     */
+    const make: <S extends Record<string, unknown>>(options?: 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" },
+     * });
+     * ```
+     */
+    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;
+    /**
+     * Forwards messages from one stream to another (or multiple).
+     *
+     * @example
+     * ```ts
+     * const stop = Stream.forward({
+     *   from: authStream,
+     *   to: analyticsStream,
+     *   only: ["userLoggedIn"],
+     * });
+     * ```
+     */
+    const forward: <S extends Record<string, unknown>>(options: 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 }
+     * );
+     * ```
+     */
+    const listen: <S extends Record<string, unknown>, K extends keyof S & string>(stream: Stream<S>, events: K | ReadonlyArray<K>, options?: SequenceOptions<S>) => ListenerBuilder<S>;
+}
+
 type TheseFirst<T> = WithKind<"First"> & WithFirst<T>;
 type TheseSecond<T> = WithKind<"Second"> & WithSecond<T>;
 type TheseBoth<First, Second> = WithKind<"Both"> & WithFirst<First> & WithSecond<Second>;
@@ -2859,4 +3019,4 @@ declare namespace Tuple {
     const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
 }
 
-export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };
+export { Combinable, Deferred, type Failure, Lazy, Lens, type Loading, Logged, Maybe, type NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, Stream, type Success, Task, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple };

package/dist/core.js

@@ -37,6 +37,7 @@ __export(Core_exports, {
   Resource: () => Resource,
   Result: () => Result,
   State: () => State,
+  Stream: () => Stream,
   Task: () => Task,
   TaskMaybe: () => TaskMaybe,
   TaskResult: () => TaskResult,
@@ -1805,6 +1806,136 @@ var State;
   };
 })(State || (State = {}));
 
+// src/Core/Stream.ts
+var Stream;
+((Stream2) => {
+  Stream2.make = (options) => ({
+    options,
+    _listeners: /* @__PURE__ */ new Set(),
+    _queue: [],
+    _isEmitting: false
+  });
+  Stream2.emit = (target, message) => {
+    const targets = Array.isArray(target) ? target : [target];
+    const msg = message;
+    for (const stream of targets) {
+      stream._queue.push(msg);
+      if (!stream._isEmitting) {
+        stream._isEmitting = true;
+        try {
+          while (stream._queue.length > 0) {
+            const nextMsg = stream._queue.shift();
+            const listeners = Array.from(stream._listeners);
+            for (const listener of listeners) {
+              try {
+                listener(nextMsg);
+              } catch (err2) {
+                if (stream.options?.onError) {
+                  stream.options.onError(err2);
+                } else {
+                  throw err2;
+                }
+              }
+            }
+          }
+        } finally {
+          stream._isEmitting = false;
+        }
+      }
+    }
+  };
+  Stream2.forward = (options) => {
+    const targets = Array.isArray(options.to) ? options.to : [options.to];
+    const filterSet = options.only ? new Set(options.only) : null;
+    const handler = (msg) => {
+      if (filterSet !== null && !filterSet.has(msg.kind)) {
+        return;
+      }
+      for (const target of targets) {
+        (0, Stream2.emit)(target, msg);
+      }
+    };
+    options.from._listeners.add(handler);
+    return () => {
+      options.from._listeners.delete(handler);
+    };
+  };
+  Stream2.listen = (stream, events, options) => {
+    const eventList = Array.isArray(events) ? events : [events];
+    const isOrdered = options?.ordered ?? false;
+    const isStrict = options?.strict ?? false;
+    const isOnce = options?.once ?? false;
+    const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+    const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
+    const createMatcher = (onMatch) => {
+      let sequenceIndex = 0;
+      return (msg) => {
+        if (resetKinds !== null && resetKinds.has(msg.kind)) {
+          sequenceIndex = 0;
+          return;
+        }
+        if (!isOrdered) {
+          if (eventList.includes(msg.kind)) {
+            onMatch(msg);
+          }
+          return;
+        }
+        let expectedKind = eventList[sequenceIndex];
+        if (expectedKind !== msg.kind && optionalKinds !== null) {
+          let lookaheadIndex = sequenceIndex;
+          while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) {
+            lookaheadIndex++;
+          }
+          if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
+            sequenceIndex = lookaheadIndex;
+            expectedKind = eventList[sequenceIndex];
+          }
+        }
+        if (msg.kind === expectedKind) {
+          sequenceIndex++;
+          if (sequenceIndex === eventList.length) {
+            sequenceIndex = 0;
+            onMatch(msg);
+          }
+        } else if (isStrict) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        } else if (eventList.includes(msg.kind)) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        }
+      };
+    };
+    return {
+      reduce: (reducer, initialState) => {
+        let currentState = initialState;
+        const listenerFn = createMatcher((msg) => {
+          currentState = reducer(msg, currentState);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return { unsubscribe, getState: () => currentState };
+      },
+      tap: (effect) => {
+        const listenerFn = createMatcher((msg) => {
+          effect(msg);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return unsubscribe;
+      }
+    };
+  };
+})(Stream || (Stream = {}));
+
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
@@ -2551,6 +2682,7 @@ var Validation;
   Resource,
   Result,
   State,
+  Stream,
   Task,
   TaskMaybe,
   TaskResult,

package/dist/core.mjs

@@ -16,6 +16,7 @@ import {
   Resource,
   Result,
   State,
+  Stream,
   Task,
   TaskMaybe,
   TaskResult,
@@ -23,7 +24,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-LR63GW6J.mjs";
+} from "./chunk-U64ASY7P.mjs";
 import "./chunk-DENXUTKL.mjs";
 export {
   Combinable,
@@ -43,6 +44,7 @@ export {
   Resource,
   Result,
   State,
+  Stream,
   Task,
   TaskMaybe,
   TaskResult,

package/dist/data.mjs

@@ -7,8 +7,8 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-UGVU2RTM.mjs";
-import "./chunk-LR63GW6J.mjs";
+} from "./chunk-6N27QZFK.mjs";
+import "./chunk-U64ASY7P.mjs";
 import "./chunk-DENXUTKL.mjs";
 export {
   Arr,

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, tuple, uncurry, uncurry3, uncurry4, untuple } from './composition.mjs';
-export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.mjs';
+export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Stream, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.mjs';
 export { D as Deferred } from './InternalTypes-CDiDBAY4.mjs';
 export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-D-aARYlP.mjs';
 export { Arr, BigNum, Dict, Json, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './data.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, tuple, uncurry, uncurry3, uncurry4, untuple } from './composition.js';
-export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.js';
+export { Combinable, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Stream, Success, These, TheseBoth, TheseFirst, TheseSecond, Tuple } from './core.js';
 export { D as Deferred } from './InternalTypes-LdhLQx3N.js';
 export { E as Equality, a as Err, F as Failed, M as Maybe, N as None, O as Ok, b as Ordering, P as Passed, R as Result, S as Some, T as Task, c as TaskMaybe, d as TaskResult, e as TaskValidation, V as Validation } from './Validation-1OgJJdeA.js';
 export { Arr, BigNum, Dict, Json, NonEmptyMap, NonEmptyRecord, NonEmptySet, NonEmptyString, Num, Rec, Str, Uniq } from './data.js';

package/dist/index.js

@@ -47,6 +47,7 @@ __export(src_exports, {
   RetryPolicy: () => RetryPolicy,
   State: () => State,
   Str: () => Str,
+  Stream: () => Stream,
   Task: () => Task,
   TaskMaybe: () => TaskMaybe,
   TaskResult: () => TaskResult,
@@ -2287,6 +2288,136 @@ var State;
   };
 })(State || (State = {}));
 
+// src/Core/Stream.ts
+var Stream;
+((Stream2) => {
+  Stream2.make = (options) => ({
+    options,
+    _listeners: /* @__PURE__ */ new Set(),
+    _queue: [],
+    _isEmitting: false
+  });
+  Stream2.emit = (target, message) => {
+    const targets = Array.isArray(target) ? target : [target];
+    const msg = message;
+    for (const stream of targets) {
+      stream._queue.push(msg);
+      if (!stream._isEmitting) {
+        stream._isEmitting = true;
+        try {
+          while (stream._queue.length > 0) {
+            const nextMsg = stream._queue.shift();
+            const listeners = Array.from(stream._listeners);
+            for (const listener of listeners) {
+              try {
+                listener(nextMsg);
+              } catch (err2) {
+                if (stream.options?.onError) {
+                  stream.options.onError(err2);
+                } else {
+                  throw err2;
+                }
+              }
+            }
+          }
+        } finally {
+          stream._isEmitting = false;
+        }
+      }
+    }
+  };
+  Stream2.forward = (options) => {
+    const targets = Array.isArray(options.to) ? options.to : [options.to];
+    const filterSet = options.only ? new Set(options.only) : null;
+    const handler = (msg) => {
+      if (filterSet !== null && !filterSet.has(msg.kind)) {
+        return;
+      }
+      for (const target of targets) {
+        (0, Stream2.emit)(target, msg);
+      }
+    };
+    options.from._listeners.add(handler);
+    return () => {
+      options.from._listeners.delete(handler);
+    };
+  };
+  Stream2.listen = (stream, events, options) => {
+    const eventList = Array.isArray(events) ? events : [events];
+    const isOrdered = options?.ordered ?? false;
+    const isStrict = options?.strict ?? false;
+    const isOnce = options?.once ?? false;
+    const resetKinds = options?.reset ? new Set(Array.isArray(options.reset) ? options.reset : [options.reset]) : null;
+    const optionalKinds = options?.optional ? new Set(Array.isArray(options.optional) ? options.optional : [options.optional]) : null;
+    const createMatcher = (onMatch) => {
+      let sequenceIndex = 0;
+      return (msg) => {
+        if (resetKinds !== null && resetKinds.has(msg.kind)) {
+          sequenceIndex = 0;
+          return;
+        }
+        if (!isOrdered) {
+          if (eventList.includes(msg.kind)) {
+            onMatch(msg);
+          }
+          return;
+        }
+        let expectedKind = eventList[sequenceIndex];
+        if (expectedKind !== msg.kind && optionalKinds !== null) {
+          let lookaheadIndex = sequenceIndex;
+          while (lookaheadIndex < eventList.length && optionalKinds.has(eventList[lookaheadIndex]) && eventList[lookaheadIndex] !== msg.kind) {
+            lookaheadIndex++;
+          }
+          if (lookaheadIndex < eventList.length && eventList[lookaheadIndex] === msg.kind) {
+            sequenceIndex = lookaheadIndex;
+            expectedKind = eventList[sequenceIndex];
+          }
+        }
+        if (msg.kind === expectedKind) {
+          sequenceIndex++;
+          if (sequenceIndex === eventList.length) {
+            sequenceIndex = 0;
+            onMatch(msg);
+          }
+        } else if (isStrict) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        } else if (eventList.includes(msg.kind)) {
+          sequenceIndex = msg.kind === eventList[0] ? 1 : 0;
+        }
+      };
+    };
+    return {
+      reduce: (reducer, initialState) => {
+        let currentState = initialState;
+        const listenerFn = createMatcher((msg) => {
+          currentState = reducer(msg, currentState);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return { unsubscribe, getState: () => currentState };
+      },
+      tap: (effect) => {
+        const listenerFn = createMatcher((msg) => {
+          effect(msg);
+          if (isOnce) {
+            stream._listeners.delete(listenerFn);
+          }
+        });
+        const unsubscribe = () => {
+          stream._listeners.delete(listenerFn);
+        };
+        stream._listeners.add(listenerFn);
+        return unsubscribe;
+      }
+    };
+  };
+})(Stream || (Stream = {}));
+
 // src/Core/TaskMaybe.ts
 var TaskMaybe;
 ((TaskMaybe2) => {
@@ -4350,6 +4481,7 @@ var Uniq;
   RetryPolicy,
   State,
   Str,
+  Stream,
   Task,
   TaskMaybe,
   TaskResult,

package/dist/index.mjs

@@ -39,7 +39,7 @@ import {
   Rec,
   Str,
   Uniq
-} from "./chunk-UGVU2RTM.mjs";
+} from "./chunk-6N27QZFK.mjs";
 import {
   Combinable,
   Deferred,
@@ -58,6 +58,7 @@ import {
   Resource,
   Result,
   State,
+  Stream,
   Task,
   TaskMaybe,
   TaskResult,
@@ -65,7 +66,7 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-LR63GW6J.mjs";
+} from "./chunk-U64ASY7P.mjs";
 import {
   Brand,
   Duration,
@@ -99,6 +100,7 @@ export {
   RetryPolicy,
   State,
   Str,
+  Stream,
   Task,
   TaskMaybe,
   TaskResult,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nlozgachev/pipelined",
-	"version": "0.48.0",
+	"version": "0.50.0",
 	"description": "Opinionated functional abstractions for TypeScript",
 	"license": "BSD-3-Clause",
 	"homepage": "https://pipelined.lozgachev.dev",
@@ -18,7 +18,7 @@
 	"types": "./dist/index.d.ts",
 	"sideEffects": false,
 	"engines": {
-		"node": ">=24"
+		"node": ">=24.19.0"
 	},
 	"files": [
 		"dist"
@@ -68,24 +68,44 @@
 		"docs:build": "pnpm --filter pipelined-docs build"
 	},
 	"devDependencies": {
-		"@size-limit/file": "12.1.0",
-		"@types/node": "25.9.3",
-		"@vitest/coverage-v8": "4.1.8",
-		"bumpp": "11.1.0",
-		"dprint": "0.54.0",
-		"fast-check": "4.8.0",
-		"oxlint": "1.69.0",
-		"size-limit": "12.1.0",
+		"@size-limit/file": "13.0.3",
+		"@types/node": "26.2.0",
+		"@vitest/coverage-v8": "4.1.10",
+		"bumpp": "12.2.0",
+		"dprint": "0.55.2",
+		"fast-check": "4.9.0",
+		"oxlint": "1.78.0",
+		"size-limit": "13.0.3",
 		"tsup": "8.5.1",
 		"typescript": "6.0.3",
-		"vitest": "4.1.8"
+		"vitest": "4.1.10"
 	},
 	"size-limit": [
-		{ "path": "dist/index.js", "limit": "25 KB", "gzip": true },
-		{ "path": "dist/core.js", "limit": "15 KB", "gzip": true },
-		{ "path": "dist/composition.js", "limit": "4 KB", "gzip": true },
-		{ "path": "dist/data.js", "limit": "12 KB", "gzip": true },
-		{ "path": "dist/types.js", "limit": "1 KB", "gzip": true }
+		{
+			"path": "dist/index.js",
+			"limit": "25 KB",
+			"gzip": true
+		},
+		{
+			"path": "dist/core.js",
+			"limit": "16 KB",
+			"gzip": true
+		},
+		{
+			"path": "dist/composition.js",
+			"limit": "4 KB",
+			"gzip": true
+		},
+		{
+			"path": "dist/data.js",
+			"limit": "13 KB",
+			"gzip": true
+		},
+		{
+			"path": "dist/types.js",
+			"limit": "2 KB",
+			"gzip": true
+		}
 	],
 	"packageManager": "pnpm@11.6.0+sha512.9a36518224080c6fe5165afdcfe79bfa118c29be703f3f462b1e32efe1e98e47e8750b148e08286250aad4113cc7993ca413c4e2cd447752708c2ee5751bc95f"
 }