@soffinal/stream 0.2.0 → 0.2.1

package/dist/reactive/list.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/reactive/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,IAAI,CAAC,KAAK,CAAE,YAAW,QAAQ,CAAC,KAAK,CAAC;IACjD,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IAEnC;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAElF;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAEjF;;;;;;;;;;;;OAYG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IAiGnC;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAIrC;;;;;;;;;;;OAWG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;;;;;;;;OAUG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAGjC;;;;;;;;;;;;OAYG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,KAAK,CAAC;CAG7C"}
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/reactive/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,IAAI,CAAC,KAAK,CAAE,YAAW,QAAQ,CAAC,KAAK,CAAC;IACjD,OAAO,CAAC,MAAM,CAAe;IAC7B,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,aAAa,CAAC,CAA0B;IAChD,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAAC;IAEnC;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAElF;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,GAAG,SAAS,CAAC,GAAG,MAAM,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC;IAEjF;;;;;;;;;;;;;;OAcG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;;;OAuBG;gBACS,KAAK,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;IAiGnC;;;;;;;;;;;;;;OAcG;IACH,GAAG,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS;IAIrC;;;;;;;;;;;;;OAaG;IACH,IAAI,MAAM,IAAI,MAAM,CAEnB;IACD;;;;;;;;;;;;OAYG;IACH,MAAM,IAAI,gBAAgB,CAAC,KAAK,CAAC;IAGjC;;;;;;;;;;;;;;OAcG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,KAAK,CAAC;CAG7C"}

package/dist/reactive/map.d.ts

@@ -6,6 +6,8 @@ import { Stream } from "../stream.ts";
  * @template KEY - The type of keys in the map
  * @template VALUE - The type of values in the map
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * ```typescript
  * const cache = new Map<string, any>();
@@ -32,6 +34,8 @@ export declare class Map<KEY, VALUE> extends globalThis.Map<KEY, VALUE> {
      * Sets a key-value pair in the map and emits the entry to listeners.
      * Only emits if the value actually changes (not same key-value pair).
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const config = new Map<string, string>();
@@ -47,6 +51,8 @@ export declare class Map<KEY, VALUE> extends globalThis.Map<KEY, VALUE> {
      * Deletes a key from the map and emits the deleted entry to listeners.
      * Only emits if the key was actually deleted (existed in map).
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const users = new Map([['alice', { age: 30 }], ['bob', { age: 25 }]]);
@@ -61,6 +67,8 @@ export declare class Map<KEY, VALUE> extends globalThis.Map<KEY, VALUE> {
      * Clears all entries from the map and emits to listeners.
      * Only emits if the map was not already empty.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const store = new Map([['a', 1], ['b', 2]]);
@@ -76,6 +84,8 @@ export declare class Map<KEY, VALUE> extends globalThis.Map<KEY, VALUE> {
      *
      * @param entries - Optional iterable of initial key-value pairs
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * // Empty map

package/dist/reactive/map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/reactive/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,GAAG,CAAC,GAAG,EAAE,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;IAC7D,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC5C,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC/C,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;;OAaG;IACK,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAEvE;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAE/D;;;;;;;;;;;;OAYG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;OAoBG;gBACS,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;CAuD7C"}
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/reactive/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,GAAG,CAAC,GAAG,EAAE,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC;IAC7D,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC5C,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC/C,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;;;;OAeG;IACK,GAAG,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAEvE;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAE/D;;;;;;;;;;;;;;OAcG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;;;;OAsBG;gBACS,OAAO,CAAC,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;CAuD7C"}

package/dist/reactive/set.d.ts

@@ -5,6 +5,8 @@ import { Stream } from "../stream.ts";
  *
  * @template VALUE - The type of values stored in the set
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * ```typescript
  * const activeUsers = new Set<string>();
@@ -31,6 +33,8 @@ export declare class Set<VALUE> extends globalThis.Set<VALUE> {
      * Adds a value to the set and emits the value to listeners.
      * Only emits if the value is actually added (not a duplicate).
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const tags = new Set<string>();
@@ -45,6 +49,8 @@ export declare class Set<VALUE> extends globalThis.Set<VALUE> {
      * Deletes a value from the set and emits the value to listeners.
      * Only emits if the value was actually deleted (existed in set).
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const items = new Set(['a', 'b', 'c']);
@@ -59,6 +65,8 @@ export declare class Set<VALUE> extends globalThis.Set<VALUE> {
      * Clears all values from the set and emits to listeners.
      * Only emits if the set was not already empty.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const cache = new Set([1, 2, 3]);
@@ -74,6 +82,8 @@ export declare class Set<VALUE> extends globalThis.Set<VALUE> {
      *
      * @param values - Optional iterable of initial values
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * // Empty set

package/dist/reactive/set.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/reactive/set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,qBAAa,GAAG,CAAC,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;IACnD,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACrC,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;OAYG;IACK,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAEtD;;;;;;;;;;;;OAYG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAE5D;;;;;;;;;;;;OAYG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;OAiBG;gBACS,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;CAqDrC"}
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/reactive/set.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,qBAAa,GAAG,CAAC,KAAK,CAAE,SAAQ,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC;IACnD,SAAS,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACrC,SAAS,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACxC,SAAS,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;IAEtC;;;;;;;;;;;;;;OAcG;IACK,GAAG,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAEtD;;;;;;;;;;;;;;OAcG;IACK,MAAM,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAE5D;;;;;;;;;;;;;;OAcG;IACK,KAAK,EAAE,CAAC,MAAM,IAAI,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAE3C;;;;;;;;;;;;;;;;;;;OAmBG;gBACS,MAAM,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC;CAqDrC"}

package/dist/reactive/state.d.ts

@@ -1,9 +1,11 @@
-import { Stream } from "../stream.ts";
+import { FunctionGenerator, Stream } from "../stream.ts";
 /**
  * A reactive state container that extends Stream to provide stateful value management.
  *
  * @template VALUE - The type of the state value
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * ```typescript
  * // Basic state
@@ -11,35 +13,29 @@ import { Stream } from "../stream.ts";
  * counter.listen(value => console.log('Counter:', value));
  * counter.value = 5; // Counter: 5
  *
- * // Complex state
- * interface User { id: string; name: string; }
- * const user = new State<User | null>(null);
+ * // State from stream
+ * const source = new Stream<number>();
+ * const state = new State(0, source);
+ * state.listen(value => console.log('State:', value));
+ * source.push(1, 2, 3); // State: 1, State: 2, State: 3
  *
- * user.listen(u => console.log('User:', u?.name || 'None'));
- * user.value = { id: '1', name: 'Alice' }; // User: Alice
+ * // State from transformed stream
+ * const filtered = source.pipe(filter({}, (_, v) => [v > 0, {}]));
+ * const derivedState = new State(-1, filtered);
  * ```
  */
 export declare class State<VALUE> extends Stream<VALUE> {
     protected _value: VALUE;
-    /**
-     * Creates a new State with an initial value.
-     *
-     * @param initialValue - The initial state value
-     *
-     * @example
-     * ```typescript
-     * const count = new State(0);
-     * const theme = new State<'light' | 'dark'>('light');
-     * const user = new State<User | null>(null);
-     * ```
-     */
     constructor(initialValue: VALUE);
+    constructor(initialValue: VALUE, stream: FunctionGenerator<VALUE> | Stream<VALUE>);
     /**
      * Updates the state with one or more values sequentially.
      * Each value triggers listeners and updates the current state.
      *
      * @param values - Values to set as state
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const state = new State(0);
@@ -53,6 +49,8 @@ export declare class State<VALUE> extends Stream<VALUE> {
     /**
      * Gets the current state value.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const state = new State('hello');
@@ -65,6 +63,8 @@ export declare class State<VALUE> extends Stream<VALUE> {
      *
      * @param value - The new state value
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const state = new State(0);

package/dist/reactive/state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/reactive/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,MAAM,CAAC,KAAK,CAAC;IAC7C,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;IAExB;;;;;;;;;;;OAWG;gBACS,YAAY,EAAE,KAAK;IAI/B;;;;;;;;;;;;;;OAcG;IACM,IAAI,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAKvC;;;;;;;;OAQG;IACH,IAAI,KAAK,IAAI,KAAK,CAEjB;IACD;;;;;;;;;;;;;OAaG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,KAAK,EAGrB;CACF"}
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../src/reactive/state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,KAAK,CAAC,KAAK,CAAE,SAAQ,MAAM,CAAC,KAAK,CAAC;IAC7C,SAAS,CAAC,MAAM,EAAE,KAAK,CAAC;gBACZ,YAAY,EAAE,KAAK;gBACnB,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAmBjF;;;;;;;;;;;;;;;;OAgBG;IACM,IAAI,CAAC,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAKvC;;;;;;;;;;OAUG;IACH,IAAI,KAAK,IAAI,KAAK,CAEjB;IACD;;;;;;;;;;;;;;;OAeG;IACH,IAAI,KAAK,CAAC,KAAK,EAAE,KAAK,EAGrB;CACF"}

package/dist/stream.d.ts

@@ -1,4 +1,5 @@
 export type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;
+export type FunctionGenerator<VALUE> = () => AsyncGenerator<VALUE, void>;
 /**
  * A reactive streaming library that provides async-first data structures with built-in event streams.
  *
@@ -26,10 +27,74 @@ export type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never
  *   if (value === 10) break;
  * }
  * ```
+ *
+ * @example
+ * // 📦 COPY-PASTE TRANSFORMERS LIBRARY - Essential transformers for immediate use
+ *
+ * // FILTERING TRANSFORMERS
+ * const simpleFilter = <T>(predicate: (value: T) => boolean | Promise<boolean>) =>
+ *   filter<T, {}>({}, async (_, value) => {
+ *     const shouldPass = await predicate(value);
+ *     return [shouldPass, {}];
+ *   });
+ *
+ * const take = <T>(n: number) =>
+ *   filter<T, { count: number }>({ count: 0 }, (state, value) => {
+ *     if (state.count >= n) return;
+ *     return [true, { count: state.count + 1 }];
+ *   });
+ *
+ * const distinct = <T>() =>
+ *   filter<T, { seen: Set<T> }>({ seen: new Set() }, (state, value) => {
+ *     if (state.seen.has(value)) return [false, state];
+ *     state.seen.add(value);
+ *     return [true, state];
+ *   });
+ *
+ * const tap = <T>(fn: (value: T) => void | Promise<void>) =>
+ *   filter<T, {}>({}, async (_, value) => {
+ *     await fn(value);
+ *     return [true, {}];
+ *   });
+ *
+ * // MAPPING TRANSFORMERS
+ * const simpleMap = <T, U>(fn: (value: T) => U | Promise<U>) =>
+ *   map<T, {}, U>({}, async (_, value) => {
+ *     const result = await fn(value);
+ *     return [result, {}];
+ *   });
+ *
+ * const withIndex = <T>() =>
+ *   map<T, { index: number }, { value: T; index: number }>(
+ *     { index: 0 },
+ *     (state, value) => [
+ *       { value, index: state.index },
+ *       { index: state.index + 1 }
+ *     ]
+ *   );
+ *
+ * const delay = <T>(ms: number) =>
+ *   map<T, {}, T>({}, async (_, value) => {
+ *     await new Promise(resolve => setTimeout(resolve, ms));
+ *     return [value, {}];
+ *   });
+ *
+ * const scan = <T, U>(fn: (acc: U, value: T) => U, initial: U) =>
+ *   map<T, { acc: U }, U>({ acc: initial }, (state, value) => {
+ *     const newAcc = fn(state.acc, value);
+ *     return [newAcc, { acc: newAcc }];
+ *   });
+ *
+ * // STATE CONVERTER
+ * const toState = <T>(initialValue: T) => (stream: Stream<T>) => {
+ *   return new State(initialValue, stream);
+ * };
+ *
+ * // Usage: stream.pipe(simpleFilter(x => x > 0)).pipe(take(5)).pipe(toState(0));
  */
 export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     protected _listeners: Set<(value: VALUE) => void>;
-    protected _generatorFn: (() => AsyncGenerator<VALUE, void>) | undefined;
+    protected _generatorFn: FunctionGenerator<VALUE> | undefined;
     protected _generator: AsyncGenerator<VALUE, void> | undefined;
     protected _listenerAdded: Stream<void> | undefined;
     protected _listenerRemoved: Stream<void> | undefined;
@@ -38,6 +103,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      *
      * @param generatorFn - Optional async generator function to produce values you can use it for creating stream with custom transformation
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * // Empty stream
@@ -66,10 +133,12 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * ```
      */
     constructor();
-    constructor(generatorFn: () => AsyncGenerator<VALUE, void>);
+    constructor(stream: FunctionGenerator<VALUE> | Stream<VALUE>);
     /**
      * Returns true if the stream has active listeners.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -86,6 +155,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     /**
      * Stream that emits when a listener is added.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -98,6 +169,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     /**
      * Stream that emits when a listener is removed.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -112,6 +185,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     /**
      * Pushes one or more values to all listeners.
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @param value - The first value to push
      * @param values - Additional values to push
      *
@@ -132,6 +207,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * @param signal - Optional AbortSignal for cleanup
      * @returns Cleanup function to remove the listener
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<string>();
@@ -155,6 +232,8 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      * @param onfulfilled - Optional transformation function
      * @returns Promise that resolves with the first value
      *
+     * @see {@link Stream} - Complete copy-paste transformers library
+     *
      * @example
      * ```typescript
      * const stream = new Stream<number>();
@@ -172,18 +251,20 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
     /**
      * Applies a transformer function to this stream, enabling functional composition.
      *
-     * @param transformer - Function that takes a stream and returns a transformed stream
-     * @returns New stream with the transformation applied
+     * @param transformer - Function that takes a stream and returns any output type
+     * @returns The result of the transformer function
+     *
+     * @see {@link Stream} - Complete copy-paste transformers library
      *
      * @example
      * ```typescript
      * const numbers = new Stream<number>();
      *
-     * // Using built-in transformers
+     * // Chain transformers
      * const result = numbers
-     *   .pipe(filter(n => n > 0))
-     *   .pipe(map(n => n * 2))
-     *   .pipe(group(batch => batch.length >= 3));
+     *   .pipe(filter({}, (_, n) => [n > 0, {}]))
+     *   .pipe(map({}, (_, n) => [n * 2, {}]))
+     *   .pipe(toState(0));
      *
      * // Custom transformer
      * const throttle = <T>(ms: number) => (stream: Stream<T>) =>
@@ -198,9 +279,11 @@ export declare class Stream<VALUE = unknown> implements AsyncIterable<VALUE> {
      *     }
      *   });
      *
-     * numbers.pipe(throttle(1000));
+     * // Transform to any type
+     * const stringResult = numbers.pipe(throttle(1000));
+     * const stateResult = numbers.pipe(toState(0));
      * ```
      */
-    pipe<OUTPUT>(transformer: (stream: Stream<VALUE>) => Stream<OUTPUT>): Stream<OUTPUT>;
+    pipe<OUTPUT extends Stream<any>>(transformer: (stream: this) => OUTPUT): OUTPUT;
 }
 //# sourceMappingURL=stream.d.ts.map

package/dist/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAEjF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,MAAM,CAAC,KAAK,GAAG,OAAO,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;IAClE,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,CAAqC;IACtF,SAAS,CAAC,YAAY,EAAE,CAAC,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,GAAG,SAAS,CAAC;IACxE,SAAS,CAAC,UAAU,EAAE,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC;IAC9D,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IACnD,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;;gBAES,WAAW,EAAE,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;IAK1D;;;;;;;;;;;;;;OAcG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;;;;;;;;;OAUG;IACH,IAAI,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,CAGhC;IAED;;;;;;;;;;;OAWG;IACH,IAAI,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,CAGlC;IACM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;IAsB5D;;;;;;;;;;;;;;OAcG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAS5C;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI;IAoCxF;;;;;;;;;;;;;;;;;;OAkBG;IACH,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC;IASzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,IAAI,CAAC,MAAM,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC;CAGrF"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../src/stream.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AACjF,MAAM,MAAM,iBAAiB,CAAC,KAAK,IAAI,MAAM,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;AACzE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,qBAAa,MAAM,CAAC,KAAK,GAAG,OAAO,CAAE,YAAW,aAAa,CAAC,KAAK,CAAC;IAClE,SAAS,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC,CAAqC;IACtF,SAAS,CAAC,YAAY,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;IAC7D,SAAS,CAAC,UAAU,EAAE,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC;IAC9D,SAAS,CAAC,cAAc,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IACnD,SAAS,CAAC,gBAAgB,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;;gBAES,MAAM,EAAE,iBAAiB,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC;IAK5D;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,YAAY,IAAI,OAAO,CAE1B;IAED;;;;;;;;;;;;OAYG;IACH,IAAI,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,CAGhC;IAED;;;;;;;;;;;;;OAaG;IACH,IAAI,eAAe,IAAI,MAAM,CAAC,IAAI,CAAC,CAGlC;IACM,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;IAsB5D;;;;;;;;;;;;;;;;OAgBG;IACH,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAS5C;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,IAAI;IAoCxF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,KAAK,KAAK,KAAK,GAAG,WAAW,CAAC,KAAK,CAAC,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC;IASzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,IAAI,CAAC,MAAM,SAAS,MAAM,CAAC,GAAG,CAAC,EAAE,WAAW,EAAE,CAAC,MAAM,EAAE,IAAI,KAAK,MAAM,GAAG,MAAM;CAGhF"}

package/dist/transformers/filter.d.ts

@@ -13,6 +13,8 @@ import { Stream } from "../stream.ts";
  *
  * @returns A transformer function that can be used with `.pipe()`
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * // Simple filtering
  * stream.pipe(filter({}, (_, value) => [value > 0, {}]))
@@ -26,38 +28,7 @@ import { Stream } from "../stream.ts";
  *   })
  * )
  *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: simpleFilter() - Simple predicate filtering
- * const simpleFilter = <T>(predicate: (value: T) => boolean | Promise<boolean>) =>
- *   filter<T, {}>({}, async (_, value) => {
- *     const shouldPass = await predicate(value);
- *     return [shouldPass, {}];
- *   });
- *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: take(n) - Limit to N items
- * const take = <T>(n: number) =>
- *   filter<T, { count: number }>({ count: 0 }, (state, value) => {
- *     if (state.count >= n) return;
- *     return [true, { count: state.count + 1 }];
- *   });
- *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: skip(n) - Skip first N items
- * const skip = <T>(n: number) =>
- *   filter<T, { count: number }>({ count: 0 }, (state, value) => {
- *     const newCount = state.count + 1;
- *     return [newCount > n, { count: newCount }];
- *   });
- *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: distinct() - Remove duplicates
- * const distinct = <T>() =>
- *   filter<T, { seen: Set<T> }>({ seen: new Set() }, (state, value) => {
- *     if (state.seen.has(value)) return [false, state];
- *     state.seen.add(value);
- *     return [true, state];
- *   });
+
  *
  */
 export declare function filter<VALUE, STATE extends Record<string, unknown> = {}>(initialState: STATE, predicate: (state: STATE, value: VALUE) => [boolean, STATE] | void | Promise<[boolean, STATE] | void>): (stream: Stream<VALUE>) => Stream<VALUE>;

package/dist/transformers/filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/transformers/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EACtE,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,GACpG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,CAAC,CAe1C"}
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/transformers/filter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EACtE,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,GAAG,OAAO,CAAC,CAAC,OAAO,EAAE,KAAK,CAAC,GAAG,IAAI,CAAC,GACpG,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,CAAC,CAe1C"}

package/dist/transformers/flat.d.ts

@@ -9,6 +9,8 @@ import { Stream } from "../stream.ts";
  *
  * @returns A transformer that flattens array values into individual events
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * // Basic flattening - 1 array → N events
  * const arrayStream = new Stream<number[]>();

package/dist/transformers/flat.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flat.d.ts","sourceRoot":"","sources":["../../src/transformers/flat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,GAAG,CAAC,EAClD,KAAK,GAAE,KAAkB,GACxB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAe5D"}
+{"version":3,"file":"flat.d.ts","sourceRoot":"","sources":["../../src/transformers/flat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,GAAG,CAAC,EAClD,KAAK,GAAE,KAAkB,GACxB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAe5D"}

package/dist/transformers/map.d.ts

@@ -14,6 +14,8 @@ import { Stream } from "../stream.ts";
  *
  * @returns A transformer function that can be used with `.pipe()`
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * // Simple transformation
  * stream.pipe(map({}, (_, value) => [value * 2, {}]))
@@ -27,37 +29,7 @@ import { Stream } from "../stream.ts";
  *   })
  * )
  *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: simpleMap() - Simple transformation
- * const simpleMap = <T, U>(fn: (value: T) => U | Promise<U>) =>
- *   map<T, {}, U>({}, async (_, value) => {
- *     const result = await fn(value);
- *     return [result, {}];
- *   });
- *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: withIndex() - Add index to values
- * const withIndex = <T>() =>
- *   map<T, { index: number }, { value: T; index: number }>(
- *     { index: 0 },
- *     (state, value) => [
- *       { value, index: state.index },
- *       { index: state.index + 1 }
- *     ]
- *   );
- *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: delay(ms) - Delay each value
- * const delay = <T>(ms: number) =>
- *   map<T, {}, T>({}, async (_, value) => {
- *     await new Promise(resolve => setTimeout(resolve, ms));
- *     return [value, {}];
- *   });
- *
- * @example
- * // 📦 COPY-PASTE TRANSFORMER: pluck(key) - Extract property
- * const pluck = <T, K extends keyof T>(key: K) =>
- *   map<T, {}, T[K]>({}, (_, value) => [value[key], {}]);
+
  *
  */
 export declare function map<VALUE, STATE extends Record<string, unknown>, MAPPED>(initialState: STATE, predicate: (state: STATE, value: VALUE) => [MAPPED, STATE] | Promise<[MAPPED, STATE]>): (stream: Stream<VALUE>) => Stream<MAPPED>;

package/dist/transformers/map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/transformers/map.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EACtE,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GACpF,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAU3C"}
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/transformers/map.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,GAAG,CAAC,KAAK,EAAE,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EACtE,YAAY,EAAE,KAAK,EACnB,SAAS,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,GACpF,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAU3C"}

package/dist/transformers/merge.d.ts

@@ -10,6 +10,8 @@ type ValueOf<STREAM> = STREAM extends Stream<infer VALUE> ? VALUE : never;
  *
  * @returns A transformer that merges all streams into one with union types
  *
+ * @see {@link Stream} - Complete copy-paste transformers library
+ *
  * @example
  * // Basic merge with type safety
  * const numbers = new Stream<number>();

package/dist/transformers/merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/transformers/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,KAAK,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAC1E,GAAG,OAAO,EAAE,OAAO,GAClB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CA0BrE"}
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/transformers/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,KAAK,OAAO,CAAC,MAAM,IAAI,MAAM,SAAS,MAAM,CAAC,MAAM,KAAK,CAAC,GAAG,KAAK,GAAG,KAAK,CAAC;AAE1E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,SAAS,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,GAAG,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,EAC1E,GAAG,OAAO,EAAE,OAAO,GAClB,CAAC,MAAM,EAAE,MAAM,CAAC,KAAK,CAAC,KAAK,MAAM,CAAC,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,CA0BrE"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@soffinal/stream",
   "module": "./dist/index.js",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A reactive event streaming library for TypeScript/JavaScript",
   "type": "module",
   "devDependencies": {

package/src/transformers/filter.md

@@ -121,8 +121,6 @@ const take = <T>(n: number) =>
   });
 ```
 
-**Psychology**: `take` demonstrates **self-limiting behavior** - the filter knows its purpose and fulfills it completely, then gracefully terminates.
-
 ### distinct - The Memory Gatekeeper
 
 ```typescript
@@ -134,7 +132,19 @@ const distinct = <T>() =>
   });
 ```
 
-**Philosophy**: `distinct` embodies **perfect memory** - it never forgets what it has seen, ensuring uniqueness through accumulated values.
+### tap - The Observer Gatekeeper
+
+```typescript
+const tap = <T>(fn: (value: T) => void | Promise<void>) =>
+  filter<T, {}>({}, async (_, value) => {
+    await fn(value);
+    return [true, {}]; // Always pass through
+  });
+
+// Usage: Side effects without changing the stream
+stream.pipe(tap((value) => console.log("Saw:", value)));
+stream.pipe(tap(async (value) => await logToDatabase(value)));
+```
 
 ## The Termination
 
@@ -151,6 +161,37 @@ const untilCondition = <T>(condition: (value: T) => boolean) =>
 
 This represents a fundamental shift from infinite streams to **purpose-driven streams** that know when their work is done.
 
+## Enhanced Pipe Integration
+
+The new pipe architecture enables seamless integration:
+
+```typescript
+// Filter integrates with any transformer
+const result = stream
+  .pipe(filter({}, (_, v) => [v > 0, {}])) // Returns Stream<T>
+  .pipe(map({}, (_, v) => [v.toString(), {}])) // Returns Stream<string>
+  .pipe(toState("0")); // Returns State<string>
+
+// Complex filtering chains
+const processed = source
+  .pipe(
+    filter({ seen: 0 }, (state, v) => {
+      if (state.seen >= 100) return; // Terminate after 100
+      return [v > 0, { seen: state.seen + 1 }];
+    })
+  )
+  .pipe(tap((v) => console.log("Positive:", v)))
+  .pipe(
+    filter({ count: 0 }, (state, v) => {
+      return [state.count % 2 === 0, { count: state.count + 1 }]; // Every other
+    })
+  );
+```
+
+**Note**: Filters compose naturally because they all speak the same language - **adaptive constraints** that can terminate, remember, and evolve.
+
+**Design insight**: Filtering State creates **conditional reactivity** - the derived state only reacts to values that pass the adaptive constraints.
+
 ## Conclusion
 
 The `filter` transformer isn't just about removing unwanted values - it's about **intelligent gatekeeping** that:

package/src/transformers/map.md

@@ -146,6 +146,36 @@ const pluck = <T, K extends keyof T>(key: K) => map<T, {}, T[K]>({}, (_, value)
 
 `pluck` demonstrates **selective transformation** - the alchemist knows exactly what it wants and ignores everything else.
 
+### tap - The Observer Gatekeeper
+
+```typescript
+const tap = <T>(fn: (value: T) => void | Promise<void>) =>
+  map<T, {}, T>({}, async (_, value) => {
+    await fn(value);
+    return [value, {}]; // Always pass through
+  });
+
+// Usage: Side effects without changing the stream
+stream.pipe(tap((value) => console.log("Saw:", value)));
+stream.pipe(tap(async (value) => await logToDatabase(value)));
+```
+
+### scan - The Accumulating Alchemist
+
+```typescript
+const scan = <T, U>(fn: (acc: U, value: T) => U, initial: U) =>
+  map<T, { acc: U }, U>({ acc: initial }, (state, value) => {
+    const newAcc = fn(state.acc, value);
+    return [newAcc, { acc: newAcc }];
+  });
+
+// Usage: Accumulate values over time
+stream.pipe(scan((sum, value) => sum + value, 0)); // Running sum
+stream.pipe(scan((max, value) => Math.max(max, value), -Infinity)); // Running max
+```
+
+`scan` demonstrates **accumulative transformation** - each value builds upon all previous values, creating a growing understanding.
+
 ## The Order Preservation
 
 Async transformations maintain order because **sequence matters**. Even if transformation B completes before transformation A, the stream waits. This isn't just about correctness - it's about **respecting the narrative** of the data.
@@ -182,3 +212,5 @@ The `map` transformer isn't just about changing values - it's about **intelligen
 - **Learns** from patterns (adaptation)
 - **Evolves** its approach over time (constraints)
 - **Preserves** the narrative order (respect)
+- **Integrates** with reactive state (toState)
+- **Accumulates** knowledge over time (scan)