aeon-core 0.1.0

package/dist/combinators/index.d.ts

@@ -0,0 +1,31 @@
+export { map } from "./map.js";
+export { filter } from "./filter.js";
+export { tap } from "./tap.js";
+export { constant } from "./constant.js";
+export { scan } from "./scan.js";
+export { reduce, observe, drain } from "./terminal.js";
+export { take, drop, takeWhile, dropWhile, slice, until, since } from "./slice.js";
+export { merge } from "./merge.js";
+export { combine, zip } from "./combine.js";
+export { switchLatest } from "./switch.js";
+export { mergeMap } from "./mergeMap.js";
+export { catchError, mapError, throwError } from "./error.js";
+export { chain } from "./chain.js";
+export { debounce, throttle, delay, bufferCount, bufferTime } from "./time.js";
+export { traverse } from "./traverse.js";
+export { fromPromise } from "./fromPromise.js";
+export { retry } from "./retry.js";
+export { share } from "./share.js";
+export { attach } from "./attach.js";
+export { dedupe } from "./dedupe.js";
+export { cons } from "./cons.js";
+export { first, last } from "./firstLast.js";
+export { pairwise } from "./pairwise.js";
+export { timeout, TimeoutError } from "./timeout.js";
+export { exhaustMap } from "./exhaustMap.js";
+export { forkJoin } from "./forkJoin.js";
+export { orElse } from "./orElse.js";
+export { ensure } from "./ensure.js";
+export { race } from "./race.js";
+export { count, all, elementAt } from "./aggregate.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/combinators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/combinators/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,eAAe,CAAC;AACvD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnF,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAC5C,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC/E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACjC,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/combinators/map.d.ts

@@ -0,0 +1,16 @@
+/**
+ * map combinator.
+ *
+ * Denotation: `map(f, e) = [(t, f(v)) | (t, v) ∈ e]`
+ *
+ * Uses pipeline fusion: map∘map is collapsed into a single map with
+ * a composed function. map∘filter becomes a filterMap node.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Transform each value in an Event stream.
+ *
+ * Denotation: `map(f, e) = [(t, f(v)) | (t, v) ∈ e]`
+ */
+export declare const map: <A, B, E>(f: (a: A) => B, event: Event<A, E>) => Event<B, E>;
+//# sourceMappingURL=map.d.ts.map

package/dist/combinators/map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/combinators/map.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC;;;;GAIG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAuB,CAAC"}

package/dist/combinators/merge.d.ts

@@ -0,0 +1,17 @@
+/**
+ * merge combinator.
+ *
+ * Denotation: `merge(e1, e2, ...) = sort by time (e1 ++ e2 ++ ...)`
+ * Ends when ALL sources have ended.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Merge multiple Event streams into one, interleaving values by time.
+ * Ends when all input streams have ended.
+ *
+ * Flattens nested merges: merge(a, merge(b, c)) → merge(a, b, c)
+ */
+export declare const merge: <A, E>(...events: Event<A, E>[]) => Event<A, E>;
+//# sourceMappingURL=merge.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/combinators/merge.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAqFnF;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CA0BhE,CAAC"}

package/dist/combinators/mergeMap.d.ts

@@ -0,0 +1,18 @@
+/**
+ * mergeMap combinator.
+ *
+ * Maps each value to an inner Event and merges the results, with
+ * bounded concurrency.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Map each value to an Event and merge the results with bounded concurrency.
+ *
+ * Denotation: `mergeMap(f, c, e) = merge(map(f, e))` with
+ * at most `c` inner streams active at any time. Values from finished
+ * inner streams are replaced by newly spawned ones from the buffer.
+ */
+export declare const mergeMap: <A, B, E>(f: (a: A) => Event<B, E>, concurrency: number, event: Event<A, E>) => Event<B, E>;
+//# sourceMappingURL=mergeMap.d.ts.map

package/dist/combinators/mergeMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeMap.d.ts","sourceRoot":"","sources":["../../src/combinators/mergeMap.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AA2HnF;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC9B,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACxB,aAAa,MAAM,EACnB,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KACjB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAwE,CAAC"}

package/dist/combinators/orElse.d.ts

@@ -0,0 +1,14 @@
+/**
+ * orElse combinator.
+ *
+ * Denotation: if the stream completes without emitting any values,
+ * emit a default value before ending.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Emit a default value if the stream completes without producing any values.
+ *
+ * Denotation: `orElse(d, e) = isEmpty(e) ? [(t_end, d)] : e`
+ */
+export declare const orElse: <A, E>(defaultValue: A, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=orElse.d.ts.map

package/dist/combinators/orElse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orElse.d.ts","sourceRoot":"","sources":["../../src/combinators/orElse.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAyCnF;;;;GAIG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,cAAc,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACZ,CAAC"}

package/dist/combinators/pairwise.d.ts

@@ -0,0 +1,14 @@
+/**
+ * pairwise combinator.
+ *
+ * Denotation: `pairwise(e) = [(t₂, [v₁, v₂]), (t₃, [v₂, v₃]), ...]`
+ * Emits [previous, current] tuples, starting from the second event.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Emit [previous, current] pairs, starting from the second event.
+ *
+ * Denotation: `pairwise(e) = [(tₙ, [vₙ₋₁, vₙ]) | n >= 2]`
+ */
+export declare const pairwise: <A, E>(event: Event<A, E>) => Event<[A, A], E>;
+//# sourceMappingURL=pairwise.d.ts.map

package/dist/combinators/pairwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.d.ts","sourceRoot":"","sources":["../../src/combinators/pairwise.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AA0CnF;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CACd,CAAC"}

package/dist/combinators/race.d.ts

@@ -0,0 +1,13 @@
+/**
+ * race combinator.
+ *
+ * Denotation: the first stream to emit wins. All others are disposed.
+ * If any stream errors before the first event, the error propagates.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Race multiple streams: the first to emit wins, others are disposed.
+ * Subsequent events come only from the winner.
+ */
+export declare const race: <A, E>(...events: Event<A, E>[]) => Event<A, E>;
+//# sourceMappingURL=race.d.ts.map

package/dist/combinators/race.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"race.d.ts","sourceRoot":"","sources":["../../src/combinators/race.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AA0FnF;;;GAGG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,QAAQ,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACV,CAAC"}

package/dist/combinators/retry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * retry combinator.
+ *
+ * Denotation: on error, re-subscribe to the source up to `maxRetries` times.
+ * Optionally delays each retry.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Duration, Event } from "aeon-types";
+/**
+ * Retry a failing event stream up to `maxRetries` times.
+ *
+ * On error, re-subscribes to the source. If `delay` is provided,
+ * waits that duration before each retry. If all retries are exhausted,
+ * the error propagates downstream.
+ */
+export declare const retry: <A, E>(maxRetries: number, event: Event<A, E>, delay?: Duration) => Event<A, E>;
+//# sourceMappingURL=retry.d.ts.map

package/dist/combinators/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../src/combinators/retry.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,QAAQ,EAAE,KAAK,EAAiC,MAAM,YAAY,CAAC;AAyF7F;;;;;;GAMG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EACxB,YAAY,MAAM,EAClB,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,QAAQ,QAAQ,KACf,KAAK,CAAC,CAAC,EAAE,CAAC,CAAwE,CAAC"}

package/dist/combinators/scan.d.ts

@@ -0,0 +1,15 @@
+/**
+ * scan combinator.
+ *
+ * Denotation: `scan(f, seed, e) = [(t, foldl f seed (values up to t)) | (t, _) ∈ e]`
+ *
+ * Includes fusion: scan(f, seed, map(g, s)) → scanMap with composed function.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Incrementally accumulate values, emitting each intermediate result.
+ *
+ * Denotation: produces a running fold of the event sequence.
+ */
+export declare const scan: <A, B, E>(f: (acc: B, a: A) => B, seed: B, event: Event<A, E>) => Event<B, E>;
+//# sourceMappingURL=scan.d.ts.map

package/dist/combinators/scan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../src/combinators/scan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAmDnF;;;;GAIG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAsB7F,CAAC"}

package/dist/combinators/share.d.ts

@@ -0,0 +1,22 @@
+/**
+ * share — replay multicast.
+ *
+ * Like multicast, but buffers the last N values and replays them
+ * to late subscribers. Useful for hot streams where late subscribers
+ * need the most recent state.
+ *
+ * Uses monomorphic classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Share a single subscription with replay for late subscribers.
+ *
+ * Buffers the last `bufferSize` values and replays them to new subscribers.
+ * Like `multicast`, the source is subscribed lazily and disposed when
+ * the last subscriber leaves.
+ *
+ * - `share(1, event)` — replay latest value (like RxJS `shareReplay(1)`)
+ * - `share(0, event)` — equivalent to `multicast` (no replay)
+ */
+export declare const share: <A, E>(bufferSize: number, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=share.d.ts.map

package/dist/combinators/share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"share.d.ts","sourceRoot":"","sources":["../../src/combinators/share.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAmHnF;;;;;;;;;GASG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,YAAY,MAAM,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACjB,CAAC"}

package/dist/combinators/slice.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Slicing combinators: take, drop, takeWhile, dropWhile, slice.
+ *
+ * Includes algebraic simplifications:
+ * - take(n, take(m, s)) → take(min(n, m), s)
+ * - drop(n, drop(m, s)) → drop(n + m, s)
+ * - take/drop on empty → empty
+ */
+import type { Event } from "aeon-types";
+/** Take the first n values from the stream, then end. */
+export declare const take: <A, E>(n: number, event: Event<A, E>) => Event<A, E>;
+/** Drop the first n values, then pass through the rest. */
+export declare const drop: <A, E>(n: number, event: Event<A, E>) => Event<A, E>;
+/** Take values while the predicate holds, then end. */
+export declare const takeWhile: <A, E>(predicate: (a: A) => boolean, event: Event<A, E>) => Event<A, E>;
+/** Drop values while the predicate holds, then pass through the rest. */
+export declare const dropWhile: <A, E>(predicate: (a: A) => boolean, event: Event<A, E>) => Event<A, E>;
+/**
+ * Take a contiguous slice: drop `start` values, then take `end - start`.
+ *
+ * Denotation: `slice(s, e, stream) = take(e - s, drop(s, stream))`
+ */
+export declare const slice: <A, E>(start: number, end: number, event: Event<A, E>) => Event<A, E>;
+/**
+ * Take values from the event until the signal fires, then end.
+ *
+ * Denotation: `until(signal, e) = [(t, v) | (t, v) ∈ e, t < t_signal]`
+ * where `t_signal` is the time of the first occurrence in `signal`.
+ */
+export declare const until: <A, E>(signal: Event<unknown, E>, event: Event<A, E>) => Event<A, E>;
+/**
+ * Drop values from the event until the signal fires, then pass through the rest.
+ *
+ * Denotation: `since(signal, e) = [(t, v) | (t, v) ∈ e, t >= t_signal]`
+ * where `t_signal` is the time of the first occurrence in `signal`.
+ */
+export declare const since: <A, E>(signal: Event<unknown, E>, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=slice.d.ts.map

package/dist/combinators/slice.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slice.d.ts","sourceRoot":"","sources":["../../src/combinators/slice.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAyEnF,yDAAyD;AACzD,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAiBpE,CAAC;AAgDF,2DAA2D;AAC3D,eAAO,MAAM,IAAI,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAepE,CAAC;AA6CF,uDAAuD;AACvD,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAC5B,CAAC;AAsClE,yEAAyE;AACzE,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,CAAC,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAC5B,CAAC;AAIlE;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAChD,CAAC;AAqExC;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAChB,CAAC;AA2DvE;;;;;GAKG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,QAAQ,KAAK,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAChB,CAAC"}

package/dist/combinators/switch.d.ts

@@ -0,0 +1,17 @@
+/**
+ * switchLatest combinator.
+ *
+ * Denotation: given an Event of Events, always listens to the most
+ * recently emitted inner Event, disposing previous subscriptions.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Switch to the latest inner Event, disposing the previous.
+ *
+ * Denotation: flatten an Event<Event<A, E>, E> by always following
+ * the most recently emitted inner event.
+ */
+export declare const switchLatest: <A, E>(event: Event<Event<A, E>, E>) => Event<A, E>;
+//# sourceMappingURL=switch.d.ts.map

package/dist/combinators/switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"switch.d.ts","sourceRoot":"","sources":["../../src/combinators/switch.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAuFnF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACzB,CAAC"}

package/dist/combinators/tap.d.ts

@@ -0,0 +1,12 @@
+/**
+ * tap combinator.
+ *
+ * Runs a side effect for each value without altering the stream.
+ * Denotation: identity on the event sequence (side effects are invisible to the denotation).
+ */
+import type { Event } from "aeon-types";
+/**
+ * Run a side-effect for each event value, passing values through unchanged.
+ */
+export declare const tap: <A, E>(f: (a: A) => void, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=tap.d.ts.map

package/dist/combinators/tap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../src/combinators/tap.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAiCnF;;GAEG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACzB,CAAC"}

package/dist/combinators/terminal.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Terminal combinators: reduce, observe, drain.
+ *
+ * These activate (subscribe to) the stream and return a Promise
+ * that resolves when the stream ends.
+ *
+ * Uses monomorphic Sink classes for V8 hidden class stability.
+ * Hot paths use local variable hoisting for function properties.
+ */
+import { type Event, type Scheduler } from "aeon-types";
+/**
+ * Fold all values into a single result. Activates the stream.
+ *
+ * Denotation: `reduce(f, seed, e) = foldl f seed (map snd e)`
+ *
+ * Uses sync loop compilation when the source chain is fully synchronous,
+ * bypassing the Sink protocol for a tight for-loop.
+ */
+export declare const reduce: <A, B, E>(f: (acc: B, a: A) => B, seed: B, event: Event<A, E>, scheduler: Scheduler) => Promise<B>;
+/**
+ * Run a side-effect for each value. Activates the stream.
+ *
+ * Denotation: executes the effect for each `(t, v)` in the event sequence.
+ */
+export declare const observe: <A, E>(f: (a: A) => void, event: Event<A, E>, scheduler: Scheduler) => Promise<void>;
+/**
+ * Activate the stream, discarding all values. Returns when the stream ends.
+ *
+ * Denotation: activates the event sequence purely for its effects.
+ */
+export declare const drain: <A, E>(event: Event<A, E>, scheduler: Scheduler) => Promise<void>;
+//# sourceMappingURL=terminal.d.ts.map

package/dist/combinators/terminal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminal.d.ts","sourceRoot":"","sources":["../../src/combinators/terminal.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAiB,KAAK,KAAK,EAAE,KAAK,SAAS,EAAwB,MAAM,YAAY,CAAC;AAoF7F;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC5B,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EACtB,MAAM,CAAC,EACP,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,WAAW,SAAS,KACnB,OAAO,CAAC,CAAC,CAmBX,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAC1B,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,EACjB,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,WAAW,SAAS,KACnB,OAAO,CAAC,IAAI,CAkBd,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,WAAW,SAAS,KAAG,OAAO,CAAC,IAAI,CAelF,CAAC"}

package/dist/combinators/time.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Time-based combinators: debounce, throttle, delay, bufferTime, bufferCount.
+ *
+ * These use the Scheduler for timing and are the async boundary
+ * where push meets scheduled execution.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Duration, Event } from "aeon-types";
+/**
+ * Wait for a quiet period before emitting the latest value.
+ * Each new value resets the timer.
+ *
+ * Denotation: emits the last value in each burst, after `duration` of silence.
+ */
+export declare const debounce: <A, E>(duration: Duration, event: Event<A, E>) => Event<A, E>;
+/**
+ * Emit at most one value per duration window.
+ * Takes the first value in each window, ignores the rest.
+ *
+ * Denotation: rate-limits the event sequence.
+ */
+export declare const throttle: <A, E>(duration: Duration, event: Event<A, E>) => Event<A, E>;
+/**
+ * Delay each event by a fixed duration.
+ *
+ * Denotation: `delay(d, e) = [(t + d, v) | (t, v) ∈ e]`
+ */
+export declare const delay: <A, E>(duration: Duration, event: Event<A, E>) => Event<A, E>;
+/**
+ * Buffer values into arrays of a fixed size.
+ * Emits when the buffer reaches `count`. Flushes remaining on end.
+ */
+export declare const bufferCount: <A, E>(count: number, event: Event<A, E>) => Event<A[], E>;
+/**
+ * Buffer values over a time window.
+ * Emits the buffer contents at the end of each window.
+ */
+export declare const bufferTime: <A, E>(duration: Duration, event: Event<A, E>) => Event<A[], E>;
+//# sourceMappingURL=time.d.ts.map

package/dist/combinators/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../../src/combinators/time.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAEV,QAAQ,EACR,KAAK,EAMN,MAAM,YAAY,CAAC;AAuFpB;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,UAAU,QAAQ,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACnB,CAAC;AAuChE;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,UAAU,QAAQ,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACnB,CAAC;AAqEhE;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,EAAE,CAAC,EAAE,UAAU,QAAQ,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CACnB,CAAC;AAmD7D;;;GAGG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,EAAE,CAAC,EAAE,OAAO,MAAM,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CACnB,CAAC;AAsEhE;;;GAGG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAAE,UAAU,QAAQ,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CACrB,CAAC"}

package/dist/combinators/timeout.d.ts

@@ -0,0 +1,20 @@
+/**
+ * timeout combinator.
+ *
+ * Denotation: error if no event is emitted within a time window.
+ * After each event, the timer resets. If the timer expires before
+ * the next event (or the first event), an error is emitted.
+ */
+import type { Duration, Event } from "aeon-types";
+declare class TimeoutError extends Error {
+    constructor(duration: Duration);
+}
+/**
+ * Error if no event is emitted within `duration`.
+ * The timer starts immediately and resets after each event.
+ *
+ * Emits a TimeoutError via the error channel.
+ */
+export declare const timeout: <A, E>(duration: Duration, event: Event<A, E>) => Event<A, E | TimeoutError>;
+export { TimeoutError };
+//# sourceMappingURL=timeout.d.ts.map

package/dist/combinators/timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeout.d.ts","sourceRoot":"","sources":["../../src/combinators/timeout.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAEV,QAAQ,EACR,KAAK,EAMN,MAAM,YAAY,CAAC;AAGpB,cAAM,YAAa,SAAQ,KAAK;gBAClB,QAAQ,EAAE,QAAQ;CAI/B;AAkFD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,UAAU,QAAQ,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,YAAY,CAClC,CAAC;AAE/D,OAAO,EAAE,YAAY,EAAE,CAAC"}

package/dist/combinators/traverse.d.ts

@@ -0,0 +1,21 @@
+/**
+ * traverse combinator.
+ *
+ * Applies an async function to each event value with bounded concurrency.
+ * When all concurrency slots are occupied, incoming values are buffered.
+ *
+ * Uses monomorphic classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Apply an async function to each event value with bounded concurrency.
+ *
+ * Denotation: `traverse(f, c, e) = [(t, await f(v)) | (t, v) ∈ e]`
+ * with at most `c` pending promises at any time. When all slots are
+ * occupied, incoming values are buffered until a slot frees up.
+ *
+ * Results are emitted as promises resolve, so output order may differ
+ * from input order when concurrency > 1.
+ */
+export declare const traverse: <A, B, E>(f: (a: A) => Promise<B>, concurrency: number, event: Event<A, E>) => Event<B, E>;
+//# sourceMappingURL=traverse.d.ts.map

package/dist/combinators/traverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse.d.ts","sourceRoot":"","sources":["../../src/combinators/traverse.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AA+GnF;;;;;;;;;GASG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAC9B,GAAG,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC,CAAC,CAAC,EACvB,aAAa,MAAM,EACnB,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KACjB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAwE,CAAC"}

package/dist/constructors.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Event constructors.
+ *
+ * Each constructor creates an Event<A, E> backed by a Source
+ * that produces events according to its denotational meaning.
+ */
+import { type Disposable, type Duration, type Event, type Scheduler, type Sink, type Source, type Time } from "aeon-types";
+declare class EmptySource<A> implements Source<A, never> {
+    readonly _sync: true;
+    constructor();
+    run(sink: Sink<A, never>, scheduler: Scheduler): Disposable;
+    syncIterate(_emit: (value: A) => boolean): void;
+}
+declare class NowSource<A> implements Source<A, never> {
+    readonly value: A;
+    readonly _sync: true;
+    constructor(value: A);
+    run(sink: Sink<A, never>, scheduler: Scheduler): Disposable;
+    syncIterate(emit: (value: A) => boolean): void;
+}
+declare const EMPTY_SOURCE: EmptySource<never>;
+/** @internal — used by combinators for instanceof detection */
+export { EmptySource as _EmptySource, NowSource as _NowSource, EMPTY_SOURCE as _EMPTY_SOURCE };
+/**
+ * An Event that ends immediately without emitting any values.
+ *
+ * Denotation: `[]` — the empty sequence.
+ */
+export declare const empty: <A>() => Event<A, never>;
+/**
+ * An Event that never emits and never ends.
+ *
+ * Denotation: `_|_` — bottom / divergent.
+ */
+export declare const never: <A>() => Event<A, never>;
+/**
+ * An Event that emits a single value at time 0, then ends.
+ *
+ * Denotation: `[(0, value)]`
+ */
+export declare const now: <A>(value: A) => Event<A, never>;
+/**
+ * An Event that emits a single value at a specific time, then ends.
+ *
+ * Denotation: `[(time, value)]`
+ */
+export declare const at: <A>(time: Time, value: A) => Event<A, never>;
+/**
+ * An Event that emits all values from an array synchronously, then ends.
+ *
+ * Denotation: `[(t, values[0]), (t, values[1]), ...]` all at the same time.
+ */
+export declare const fromArray: <A>(values: readonly A[]) => Event<A, never>;
+/**
+ * An Event that emits undefined at regular intervals.
+ *
+ * Denotation: `[(period, undefined), (2*period, undefined), ...]`
+ */
+export declare const periodic: (period: Duration) => Event<undefined, never>;
+/**
+ * An Event that emits a sequence of numbers synchronously, then ends.
+ *
+ * Denotation: `[(t, start), (t, start+1), ..., (t, start+count-1)]`
+ */
+export declare const range: (start: number, count: number) => Event<number, never>;
+/**
+ * Create an Event from an iterable, emitting all values synchronously.
+ *
+ * Denotation: `[(t, v) for v in iterable]` all at the same time.
+ */
+export declare const fromIterable: <A>(iterable: Iterable<A>) => Event<A, never>;
+//# sourceMappingURL=constructors.d.ts.map

package/dist/constructors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constructors.d.ts","sourceRoot":"","sources":["../src/constructors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,QAAQ,EACb,KAAK,KAAK,EACV,KAAK,SAAS,EACd,KAAK,IAAI,EACT,KAAK,MAAM,EACX,KAAK,IAAI,EAEV,MAAM,YAAY,CAAC;AAMpB,cAAM,WAAW,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;IAC9C,SAAiB,KAAK,EAAE,IAAI,CAAC;;IAM7B,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,SAAS;IAK9C,WAAW,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI;CAChD;AAQD,cAAM,SAAS,CAAC,CAAC,CAAE,YAAW,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC;IAC5C,SAAiB,KAAK,EAAE,CAAC,CAAC;IAC1B,SAAiB,KAAK,EAAE,IAAI,CAAC;gBAEjB,KAAK,EAAE,CAAC;IAKpB,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,SAAS,EAAE,SAAS;IAO9C,WAAW,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,GAAG,IAAI;CAG/C;AA+BD,QAAA,MAAM,YAAY,oBAA2B,CAAC;AAK9C,+DAA+D;AAC/D,OAAO,EAAE,WAAW,IAAI,YAAY,EAAE,SAAS,IAAI,UAAU,EAAE,YAAY,IAAI,aAAa,EAAE,CAAC;AAI/F;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,OAAK,KAAK,CAAC,CAAC,EAAE,KAAK,CACiB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,CAAC,OAAK,KAAK,CAAC,CAAC,EAAE,KAAK,CACiB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,KAAK,CAAuC,CAAC;AA2BxF;;;;GAIG;AACH,eAAO,MAAM,EAAE,GAAI,CAAC,EAAE,MAAM,IAAI,EAAE,OAAO,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,KAAK,CAClB,CAAC;AAE1C;;;;GAIG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,QAAQ,SAAS,CAAC,EAAE,KAAG,KAAK,CAAC,CAAC,EAAE,KAAK,CAC3B,CAAC;AAsCxC;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,QAAQ,QAAQ,KAAG,KAAK,CAAC,SAAS,EAAE,KAAK,CACxB,CAAC;AA+B3C;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,OAAO,MAAM,KAAG,KAAK,CAAC,MAAM,EAAE,KAAK,CACd,CAAC;AA2B3D;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,UAAU,QAAQ,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,KAAK,CAC1B,CAAC"}

package/dist/fluent.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Fluent API wrapper for Event streams.
+ *
+ * Provides a chainable interface: `fluent(event).map(f).filter(p).take(10)`
+ * All methods delegate to standalone combinators — zero logic duplication.
+ *
+ * This is a separate entry point so tree-shaking eliminates it when unused.
+ */
+import type { Behavior, Duration, Event, Scheduler } from "aeon-types";
+/**
+ * Chainable wrapper around a pulse Event.
+ *
+ * Every method returns a new FluentEvent (or a terminal value like Promise).
+ * The underlying Event is accessible via `.event`.
+ */
+export declare class FluentEvent<A, E> {
+    readonly event: Event<A, E>;
+    constructor(event: Event<A, E>);
+    map<B>(f: (a: A) => B): FluentEvent<B, E>;
+    filter(predicate: (a: A) => boolean): FluentEvent<A, E>;
+    tap(f: (a: A) => void): FluentEvent<A, E>;
+    constant<B>(value: B): FluentEvent<B, E>;
+    scan<B>(f: (acc: B, a: A) => B, seed: B): FluentEvent<B, E>;
+    dedupe(eq?: (a: A, b: A) => boolean): FluentEvent<A, E>;
+    cons(value: A): FluentEvent<A, E>;
+    pairwise(): FluentEvent<[A, A], E>;
+    first(predicate?: (a: A) => boolean): FluentEvent<A, E>;
+    last(predicate?: (a: A) => boolean): FluentEvent<A, E>;
+    take(n: number): FluentEvent<A, E>;
+    drop(n: number): FluentEvent<A, E>;
+    takeWhile(predicate: (a: A) => boolean): FluentEvent<A, E>;
+    dropWhile(predicate: (a: A) => boolean): FluentEvent<A, E>;
+    slice(start: number, end: number): FluentEvent<A, E>;
+    until(signal: Event<unknown, E>): FluentEvent<A, E>;
+    since(signal: Event<unknown, E>): FluentEvent<A, E>;
+    merge(...others: Event<A, E>[]): FluentEvent<A, E>;
+    combine<B, C>(f: (a: A, b: B) => C, other: Event<B, E>): FluentEvent<C, E>;
+    zip<B>(other: Event<B, E>): FluentEvent<[A, B], E>;
+    chain<B>(f: (a: A) => Event<B, E>): FluentEvent<B, E>;
+    mergeMap<B>(f: (a: A) => Event<B, E>, concurrency: number): FluentEvent<B, E>;
+    traverse<B>(f: (a: A) => Promise<B>, concurrency: number): FluentEvent<B, E>;
+    exhaustMap<B>(f: (a: A) => Event<B, E>): FluentEvent<B, E>;
+    catchError<E2>(handler: (err: E) => Event<A, E2>): FluentEvent<A, E2>;
+    mapError<E2>(f: (err: E) => E2): FluentEvent<A, E2>;
+    debounce(duration: Duration): FluentEvent<A, E>;
+    throttle(duration: Duration): FluentEvent<A, E>;
+    delay(duration: Duration): FluentEvent<A, E>;
+    bufferCount(count: number): FluentEvent<A[], E>;
+    bufferTime(duration: Duration): FluentEvent<A[], E>;
+    sample<B>(behavior: Behavior<B, E>): FluentEvent<B, E>;
+    snapshot<B, C>(f: (b: B, a: A) => C, behavior: Behavior<B, E>): FluentEvent<C, E>;
+    retry(maxRetries: number, delayDuration?: Duration): FluentEvent<A, E>;
+    attach<B, C>(f: (a: A, b: B) => C, sampler: Event<B, E>): FluentEvent<C, E>;
+    timeout(duration: Duration): FluentEvent<A, import("./index.js").TimeoutError | E>;
+    orElse(value: A): FluentEvent<A, E>;
+    ensure(cleanup: () => void): FluentEvent<A, E>;
+    count(): FluentEvent<number, E>;
+    all(predicate: (a: A) => boolean): FluentEvent<boolean, E>;
+    elementAt(n: number): FluentEvent<A, E>;
+    race(...others: Event<A, E>[]): FluentEvent<A, E>;
+    multicast(): FluentEvent<A, E>;
+    share(bufferSize: number): FluentEvent<A, E>;
+    toAsyncIterator(scheduler: Scheduler): AsyncIterableIterator<A> & {
+        dispose(): void;
+    };
+    reduce<B>(f: (acc: B, a: A) => B, seed: B, scheduler: Scheduler): Promise<B>;
+    observe(f: (a: A) => void, scheduler: Scheduler): Promise<void>;
+    drain(scheduler: Scheduler): Promise<void>;
+}
+/**
+ * Wrap a pulse Event in a chainable fluent interface.
+ *
+ * ```typescript
+ * const result = await fluent(fromArray([1, 2, 3, 4, 5]))
+ *   .filter(x => x % 2 === 0)
+ *   .map(x => x * 10)
+ *   .take(2)
+ *   .reduce((acc, x) => acc + x, 0, scheduler);
+ * // result === 60
+ * ```
+ */
+export declare const fluent: <A, E>(event: Event<A, E>) => FluentEvent<A, E>;
+//# sourceMappingURL=fluent.d.ts.map

package/dist/fluent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fluent.d.ts","sourceRoot":"","sources":["../src/fluent.ts"],"names":[],"mappings":"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"}