aeon-core 0.1.0

package/README.md

@@ -0,0 +1,87 @@
+# aeon-core
+
+The main package of [Aeon](https://github.com/joshburgess/aeon), a denotationally-designed reactive programming library for TypeScript.
+
+Aeon provides two core abstractions with precise mathematical semantics:
+
+- **`Event<A, E>`** — a discrete stream of time-stamped values with a typed error channel
+- **`Behavior<A, E>`** — a continuous function from time to a value, evaluated lazily when sampled
+
+## Features
+
+- **Denotational semantics** — every combinator has a formal mathematical meaning
+- **Typed error channel** — `E = never` means a stream provably cannot fail
+- **V8-optimized** — monomorphic sink classes, hidden class discipline, construction-time pipeline fusion
+- **Three API styles** — data-first composition, `pipe()` with data-last curried operators (`P.*`), fluent chainable methods
+- **Behaviors** — continuous-time values with generation-based dirty-flag caching, plus numerical integration and differentiation
+- **Comprehensive** — 50+ operators covering transforms, slicing, combining, higher-order, error handling, time, and aggregation
+- **Small** — 1.5 KB gzipped minimal import, 8.3 KB full library
+
+## Installation
+
+```bash
+pnpm add aeon-core aeon-scheduler
+```
+
+## Quick Start
+
+```typescript
+import { fromArray, map, filter, observe } from "aeon-core";
+import { DefaultScheduler } from "aeon-scheduler";
+
+const scheduler = new DefaultScheduler();
+
+await observe(
+  (v) => console.log(v),
+  map(
+    (x) => x * 2,
+    filter((x) => x % 2 === 0, fromArray([1, 2, 3, 4, 5])),
+  ),
+  scheduler,
+);
+// 4, 8
+```
+
+### Using `pipe`
+
+```typescript
+import { fromArray, pipe, observe, P } from "aeon-core";
+import { DefaultScheduler } from "aeon-scheduler";
+
+const result = pipe(
+  fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
+  P.filter((x) => x % 2 === 0),
+  P.map((x) => x * 2),
+  P.take(3),
+);
+
+await observe((v) => console.log(v), result, new DefaultScheduler());
+// 4, 8, 12
+```
+
+### Using the fluent API
+
+```typescript
+import { fromArray, fluent } from "aeon-core";
+import { DefaultScheduler } from "aeon-scheduler";
+
+await fluent(fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
+  .filter((x) => x % 2 === 0)
+  .map((x) => x * 2)
+  .take(3)
+  .observe((v) => console.log(v), new DefaultScheduler());
+// 4, 8, 12
+```
+
+## Documentation
+
+- [Main README](https://github.com/joshburgess/aeon#readme)
+- [Getting Started](https://github.com/joshburgess/aeon/blob/main/docs/getting-started.md)
+- [Denotational Semantics](https://github.com/joshburgess/aeon/blob/main/docs/semantics.md)
+- [Optimizations](https://github.com/joshburgess/aeon/blob/main/OPTIMIZATIONS.md)
+- [Migration from RxJS](https://github.com/joshburgess/aeon/blob/main/docs/migration-from-rxjs.md)
+- [Migration from @most/core](https://github.com/joshburgess/aeon/blob/main/docs/migration-from-most.md)
+
+## License
+
+MIT

package/dist/adapter.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Imperative push adapter.
+ *
+ * createAdapter returns a [push, event] pair. Calling push(value) sends
+ * the value to all current subscribers. This is the equivalent of
+ * RxJS's Subject, but as a clean separated push/pull pair.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Create an imperative push adapter.
+ *
+ * Returns [push, event] where:
+ * - `push(value)` sends a value to all current subscribers
+ * - `event` is a subscribable Event stream
+ */
+export declare const createAdapter: <A, E = never>() => [push: (value: A) => void, event: Event<A, E>];
+//# sourceMappingURL=adapter.d.ts.map

package/dist/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAyB,MAAM,YAAY,CAAC;AAG3E;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,OAAK,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAuB3F,CAAC"}

package/dist/asyncIterator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * AsyncIterator integration.
+ *
+ * Bridges between Event streams and the AsyncIterator protocol,
+ * providing natural backpressure via pull-based async iteration.
+ */
+import type { Disposable, Event, Scheduler } from "aeon-types";
+/**
+ * Convert an Event to an AsyncIterableIterator.
+ *
+ * Backpressure: the source pushes into a buffer. The consumer pulls
+ * via `next()`. If the consumer is slower than the producer, values
+ * buffer in memory.
+ */
+export declare const toAsyncIterator: <A, E>(event: Event<A, E>, scheduler: Scheduler) => AsyncIterableIterator<A> & Disposable;
+/**
+ * Create an Event from an AsyncIterable.
+ *
+ * The async iterable is pulled eagerly — each value is pushed
+ * to subscribers as soon as it's available.
+ */
+export declare const fromAsyncIterable: <A>(iterable: AsyncIterable<A>) => Event<A, never>;
+//# sourceMappingURL=asyncIterator.d.ts.map

package/dist/asyncIterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asyncIterator.d.ts","sourceRoot":"","sources":["../src/asyncIterator.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,KAAK,EAAE,SAAS,EAAc,MAAM,YAAY,CAAC;AAG3E;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,CAAC,EAClC,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,WAAW,SAAS,KACnB,qBAAqB,CAAC,CAAC,CAAC,GAAG,UAqF7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,CAAC,EAAE,UAAU,aAAa,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,KAAK,CA2B5E,CAAC"}

package/dist/behavior.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Behavior constructors and combinators.
+ *
+ * A Behavior is a continuous time-varying value: Time → A.
+ * These are created with constructors, transformed with Functor/Applicative
+ * operations, and bridged with Events via stepper/sample/snapshot.
+ */
+import type { Behavior, Disposable, Duration, Event, Scheduler, Time } from "aeon-types";
+import { sampleBehavior } from "./internal/behavior.js";
+/**
+ * A Behavior that always holds the same value.
+ *
+ * Denotation: `t => value`
+ */
+export declare const constantB: <A>(value: A) => Behavior<A, never>;
+/**
+ * A Behavior defined by an arbitrary function of time.
+ *
+ * Denotation: `f` itself.
+ */
+export declare const fromFunction: <A>(f: (time: Time) => A) => Behavior<A, never>;
+/**
+ * The identity Behavior — its value is the current time.
+ *
+ * Denotation: `t => t`
+ */
+export declare const time: Behavior<Time, never>;
+/**
+ * Alias for constantB — the pure/of for Behavior's Applicative.
+ */
+export declare const pureB: <A>(value: A) => Behavior<A, never>;
+/**
+ * Transform the value of a Behavior.
+ *
+ * Denotation: `mapB(f, b) = t => f(b(t))`
+ */
+export declare const mapB: <A, B, E>(f: (a: A) => B, behavior: Behavior<A, E>) => Behavior<B, E>;
+/**
+ * Lift a binary function over two Behaviors.
+ *
+ * Denotation: `liftA2B(f, ba, bb) = t => f(ba(t), bb(t))`
+ */
+export declare const liftA2B: <A1, A2, B, E>(f: (a1: A1, a2: A2) => B, ba: Behavior<A1, E>, bb: Behavior<A2, E>) => Behavior<B, E>;
+/**
+ * Lift a ternary function over three Behaviors.
+ *
+ * Denotation: `liftA3B(f, ba, bb, bc) = t => f(ba(t), bb(t), bc(t))`
+ */
+export declare const liftA3B: <A1, A2, A3, B, E>(f: (a1: A1, a2: A2, a3: A3) => B, ba: Behavior<A1, E>, bb: Behavior<A2, E>, bc: Behavior<A3, E>) => Behavior<B, E>;
+/**
+ * Lift a quaternary function over four Behaviors.
+ *
+ * Denotation: `liftA4B(f, ba, bb, bc, bd) = t => f(ba(t), bb(t), bc(t), bd(t))`
+ */
+export declare const liftA4B: <A1, A2, A3, A4, B, E>(f: (a1: A1, a2: A2, a3: A3, a4: A4) => B, ba: Behavior<A1, E>, bb: Behavior<A2, E>, bc: Behavior<A3, E>, bd: Behavior<A4, E>) => Behavior<B, E>;
+/**
+ * Lift a quinary function over five Behaviors.
+ *
+ * Denotation: `liftA5B(f, ba, bb, bc, bd, be) = t => f(ba(t), bb(t), bc(t), bd(t), be(t))`
+ */
+export declare const liftA5B: <A1, A2, A3, A4, A5, B, E>(f: (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5) => B, ba: Behavior<A1, E>, bb: Behavior<A2, E>, bc: Behavior<A3, E>, bd: Behavior<A4, E>, be: Behavior<A5, E>) => Behavior<B, E>;
+/**
+ * Create a Behavior that holds the latest value from an Event.
+ *
+ * Denotation: `stepper(init, e) = t => latestValue(e, t) ?? init`
+ *
+ * This is the primary push→pull bridge. The returned behavior is
+ * push-updated when the event fires, and pull-sampled when read.
+ *
+ * IMPORTANT: The caller must provide a scheduler to subscribe to the event.
+ * Returns [Behavior, Disposable] — the disposable unsubscribes from the event.
+ */
+export declare const stepper: <A, E>(initial: A, event: Event<A, E>, scheduler: Scheduler) => [Behavior<A, E>, Disposable];
+/**
+ * Create a Behavior that accumulates event values with a fold function.
+ *
+ * Denotation: `accumB(f, init, e) = t => foldl f init [v | (t', v) ∈ e, t' <= t]`
+ *
+ * Like `stepper` but applies a reducer to each event instead of replacing
+ * the held value. Equivalent to `stepper(init, scan(f, init, e))` but
+ * without an intermediate Event allocation.
+ */
+export declare const accumB: <A, B, E>(f: (acc: B, a: A) => B, initial: B, event: Event<A, E>, scheduler: Scheduler) => [Behavior<B, E>, Disposable];
+/**
+ * Sample a Behavior whenever a sampler Event fires.
+ *
+ * Denotation: `sample(b, sampler) = [(t, b(t)) | (t, _) ∈ sampler]`
+ */
+export declare const sample: <A, B, E>(behavior: Behavior<A, E>, sampler: Event<B, E>) => Event<A, E>;
+/**
+ * Snapshot: sample a Behavior and combine with the Event value.
+ *
+ * Denotation: `snapshot(f, b, e) = [(t, f(b(t), v)) | (t, v) ∈ e]`
+ */
+export declare const snapshot: <A, B, C, E>(f: (a: A, b: B) => C, behavior: Behavior<A, E>, event: Event<B, E>) => Event<C, E>;
+/**
+ * Dynamic Behavior switching.
+ *
+ * Holds `initial` until the event fires, then switches to the
+ * Behavior carried by each event occurrence.
+ *
+ * Denotation: holds the most recently received Behavior; samples it.
+ */
+export declare const switcher: <A, E>(initial: Behavior<A, E>, event: Event<Behavior<A, E>, E>, scheduler: Scheduler) => [Behavior<A, E>, Disposable];
+/**
+ * Flatten a Behavior of Behaviors — the Monad join for Behaviors.
+ *
+ * Denotation: `switchB(bb) = t => bb(t)(t)`
+ *
+ * At time `t`, samples the outer behavior to get the inner behavior,
+ * then samples the inner behavior at the same time. This is inherently
+ * non-cacheable (the inner behavior can change at any time).
+ */
+export declare const switchB: <A, E>(bb: Behavior<Behavior<A, E>, E>) => Behavior<A, E>;
+/**
+ * Numerical integration of a Behavior over time.
+ *
+ * Denotation: `integral(b, dt) ≈ t => ∫₀ᵗ b(s) ds`
+ *
+ * Uses the trapezoidal rule with step size `dt`. The consumer's sampling
+ * rate and the integration step size are decoupled — the integrator
+ * subdivides [0, t] into steps of size `dt` regardless of when sampling
+ * occurs.
+ */
+export declare const integral: (behavior: Behavior<number, never>, dt: Duration) => Behavior<number, never>;
+/**
+ * Numerical differentiation of a Behavior over time.
+ *
+ * Denotation: `derivative(b, dt) ≈ t => db/dt(t)`
+ *
+ * Uses the backward finite difference: `(b(t) - b(t - dt)) / dt`.
+ * At `t = 0`, returns 0 (no history). For `t < dt`, uses the
+ * available interval `[0, t]`.
+ */
+export declare const derivative: (behavior: Behavior<number, never>, dt: Duration) => Behavior<number, never>;
+/**
+ * Read the current value of a Behavior at a given time.
+ */
+export { sampleBehavior as readBehavior };
+//# sourceMappingURL=behavior.d.ts.map

package/dist/behavior.d.ts.map

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

package/dist/combinators/aggregate.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Aggregate combinators: count, every, elementAt.
+ *
+ * Simple stream aggregation operators that can be composed from
+ * primitives but are common enough to justify named combinators.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Emit the total number of values when the stream ends.
+ *
+ * Denotation: `count(e) = [(t_end, |e|)]`
+ */
+export declare const count: <A, E>(event: Event<A, E>) => Event<number, E>;
+/**
+ * Emit `true` when the stream ends if all values matched the predicate,
+ * or `false` as soon as one fails.
+ *
+ * Denotation: `all(p, e) = [(t, ∀v ∈ e. p(v))]`
+ */
+export declare const all: <A, E>(predicate: (a: A) => boolean, event: Event<A, E>) => Event<boolean, E>;
+/**
+ * Emit only the nth value (0-indexed), then end.
+ *
+ * Denotation: `elementAt(n, e) = [e[n]]` if it exists, empty otherwise.
+ */
+export declare const elementAt: <A, E>(n: number, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=aggregate.d.ts.map

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

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

package/dist/combinators/attach.d.ts

@@ -0,0 +1,21 @@
+/**
+ * attach combinator.
+ *
+ * Denotation: `attach(f, sampled, sampler)` emits
+ * `f(latestA, b)` whenever `sampler` fires, using the latest
+ * value from `sampled`. Only emits after `sampled` has produced
+ * at least one value.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Combine the latest value from one stream with each emission of another.
+ *
+ * Emits `f(latestA, b)` each time `sampler` fires, using the most recent
+ * value from `sampled`. Only emits after `sampled` has produced at least one value.
+ *
+ * The output ends when `sampler` ends. Errors from either source propagate.
+ */
+export declare const attach: <A, B, C, E>(f: (a: A, b: B) => C, sampled: Event<A, E>, sampler: Event<B, E>) => Event<C, E>;
+//# sourceMappingURL=attach.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attach.d.ts","sourceRoot":"","sources":["../../src/combinators/attach.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAkFnF;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAC/B,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EACpB,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KACnB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAgF,CAAC"}

package/dist/combinators/chain.d.ts

@@ -0,0 +1,17 @@
+/**
+ * chain combinator.
+ *
+ * Denotation: `chain(f, e) = concat(map(f, e))` — each inner stream
+ * runs to completion before the next begins.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Sequentially flatMap: for each value, create an inner Event and
+ * concatenate the results.
+ *
+ * Denotation: `chain(f, e) = concat [f(v) | (t, v) ∈ e]`
+ */
+export declare const chain: <A, B, E>(f: (a: A) => Event<B, E>, event: Event<A, E>) => Event<B, E>;
+//# sourceMappingURL=chain.d.ts.map

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

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

package/dist/combinators/combine.d.ts

@@ -0,0 +1,24 @@
+/**
+ * combine and zip combinators.
+ *
+ * combine: emits whenever either source emits, using the latest value from each.
+ * zip: emits pairwise — only when both sources have emitted a new value.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Combine two event streams using a function, emitting whenever either source emits.
+ *
+ * Denotation: emits f(latestA, latestB) at each time where either A or B fires,
+ * once both have produced at least one value.
+ */
+export declare const combine: <A, B, C, E>(f: (a: A, b: B) => C, ea: Event<A, E>, eb: Event<B, E>) => Event<C, E>;
+/**
+ * Zip two event streams pairwise.
+ *
+ * Denotation: `zip(ea, eb) = [(t, [a, b]) | (ta, a) ∈ ea, (tb, b) ∈ eb]`
+ * where pairs are consumed in order, t = max(ta, tb).
+ */
+export declare const zip: <A, B, E>(ea: Event<A, E>, eb: Event<B, E>) => Event<[A, B], E>;
+//# sourceMappingURL=combine.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"combine.d.ts","sourceRoot":"","sources":["../../src/combinators/combine.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAsGnF;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAChC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,EACpB,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACf,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KACd,KAAK,CAAC,CAAC,EAAE,CAAC,CAAuE,CAAC;AA6FrF;;;;;GAKG;AACH,eAAO,MAAM,GAAG,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAClB,CAAC"}

package/dist/combinators/cons.d.ts

@@ -0,0 +1,14 @@
+/**
+ * cons combinator.
+ *
+ * Denotation: `cons(value, e) = [(t₀, value)] ++ e`
+ * Prepends a synchronous initial value before the first event.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Prepend an initial value before the first event.
+ *
+ * Denotation: `cons(value, e) = [(t₀, value)] ++ e`
+ */
+export declare const cons: <A, E>(value: A, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=cons.d.ts.map

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

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

package/dist/combinators/constant.d.ts

@@ -0,0 +1,13 @@
+/**
+ * constant combinator.
+ *
+ * Denotation: `constant(b, e) = [(t, b) | (t, _) ∈ e]`
+ */
+import type { Event } from "aeon-types";
+/**
+ * Replace every value in the stream with a constant.
+ *
+ * Denotation: `constant(b, e) = map(_ => b, e)`
+ */
+export declare const constant: <A, B, E>(value: B, event: Event<A, E>) => Event<B, E>;
+//# sourceMappingURL=constant.d.ts.map

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

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

package/dist/combinators/dedupe.d.ts

@@ -0,0 +1,16 @@
+/**
+ * dedupe combinator.
+ *
+ * Denotation: suppress consecutive duplicate values.
+ * `dedupe(eq, e) = [(t, v) | (t, v) ∈ e, v ≠ prev]`
+ * where `prev` is the most recently emitted value.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Suppress consecutive duplicate values.
+ *
+ * Denotation: emits a value only when it differs from the previous
+ * emission, according to the provided equality function (defaults to `===`).
+ */
+export declare const dedupe: <A, E>(event: Event<A, E>, eq?: (a: A, b: A) => boolean) => Event<A, E>;
+//# sourceMappingURL=dedupe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dedupe.d.ts","sourceRoot":"","sources":["../../src/combinators/dedupe.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAwCnF;;;;;GAKG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EACzB,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,KAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAmB,KACtC,KAAK,CAAC,CAAC,EAAE,CAAC,CAA0D,CAAC"}

package/dist/combinators/ensure.d.ts

@@ -0,0 +1,13 @@
+/**
+ * ensure combinator.
+ *
+ * Denotation: run a side-effect function when the stream ends or errors.
+ * The cleanup runs exactly once.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Run a cleanup function when the stream ends, errors, or is disposed.
+ * The cleanup runs exactly once regardless of which termination path fires.
+ */
+export declare const ensure: <A, E>(cleanup: () => void, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=ensure.d.ts.map

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

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

package/dist/combinators/error.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Error handling combinators with typed error channel.
+ *
+ * The E type parameter transforms through these operations — this is
+ * the key advantage over untyped error handling.
+ *
+ * Uses monomorphic Sink/Source classes for V8 hidden class stability.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Recover from errors by switching to a new Event stream.
+ * The error type CHANGES from E1 to E2.
+ *
+ * Denotation: if the stream errors with `e`, continue with `handler(e)`.
+ */
+export declare const catchError: <A, E1, E2>(handler: (err: E1) => Event<A, E2>, event: Event<A, E1>) => Event<A, E2>;
+/**
+ * Transform the error value without changing the stream structure.
+ *
+ * Denotation: `mapError(f, e)` — the error, if any, is replaced by `f(err)`.
+ */
+export declare const mapError: <A, E1, E2>(f: (err: E1) => E2, event: Event<A, E1>) => Event<A, E2>;
+/**
+ * An Event that immediately errors with the given value.
+ *
+ * Denotation: `Error(err)` — a failed event sequence.
+ */
+export declare const throwError: <A, E>(err: E) => Event<A, E>;
+//# sourceMappingURL=error.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/combinators/error.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAc,KAAK,EAAiC,MAAM,YAAY,CAAC;AAuDnF;;;;;GAKG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAClC,SAAS,CAAC,GAAG,EAAE,EAAE,KAAK,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAClC,OAAO,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAClB,KAAK,CAAC,CAAC,EAAE,EAAE,CAA8D,CAAC;AAyC7E;;;;GAIG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,GAAG,CAAC,GAAG,EAAE,EAAE,KAAK,EAAE,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,EAAE,CACjC,CAAC;AAiBzD;;;;GAIG;AACH,eAAO,MAAM,UAAU,GAAI,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,KAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAA4C,CAAC"}

package/dist/combinators/exhaustMap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * exhaustMap combinator.
+ *
+ * Denotation: while an inner stream is active, ignore new outer values.
+ * The counterpart to switchLatest (which cancels) and mergeMap (which
+ * runs all concurrently).
+ */
+import type { Event } from "aeon-types";
+/**
+ * Map each outer value to an inner Event, ignoring new outer values
+ * while the current inner is still active.
+ *
+ * Denotation: projects outer values to inner streams, but drops
+ * projections that arrive while an inner stream is running.
+ */
+export declare const exhaustMap: <A, B, E>(f: (a: A) => Event<B, E>, event: Event<A, E>) => Event<B, E>;
+//# sourceMappingURL=exhaustMap.d.ts.map

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

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

package/dist/combinators/filter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * filter combinator.
+ *
+ * Denotation: `filter(p, e) = [(t, v) | (t, v) ∈ e, p(v)]`
+ *
+ * Uses pipeline fusion: filter∘filter is collapsed into a single filter
+ * with conjoined predicates. filter∘map becomes a mapFilter node.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Keep only values that satisfy the predicate.
+ *
+ * Denotation: `filter(p, e) = [(t, v) | (t, v) ∈ e, p(v)]`
+ */
+export declare const filter: <A, E>(predicate: (a: A) => boolean, event: Event<A, E>) => Event<A, E>;
+//# sourceMappingURL=filter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/combinators/filter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGxC;;;;GAIG;AACH,eAAO,MAAM,MAAM,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,CAC3D,CAAC"}

package/dist/combinators/firstLast.d.ts

@@ -0,0 +1,23 @@
+/**
+ * first and last combinators.
+ *
+ * first: emit only the first value (optionally matching a predicate), then end.
+ * last: emit only the final value (optionally matching a predicate) on end.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Emit only the first value, then end.
+ * With a predicate: emit the first value matching the predicate.
+ *
+ * Denotation: `first(e) = take(1, e)`
+ *             `first(p, e) = take(1, filter(p, e))`
+ */
+export declare const first: <A, E>(event: Event<A, E>, predicate?: (a: A) => boolean) => Event<A, E>;
+/**
+ * Emit only the final value when the stream ends.
+ * With a predicate: emit the last value matching the predicate.
+ *
+ * Denotation: `last(e) = let vs = values(e) in [vs[|vs|-1]]`
+ */
+export declare const last: <A, E>(event: Event<A, E>, predicate?: (a: A) => boolean) => Event<A, E>;
+//# sourceMappingURL=firstLast.d.ts.map

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

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

package/dist/combinators/forkJoin.d.ts

@@ -0,0 +1,14 @@
+/**
+ * forkJoin combinator.
+ *
+ * Denotation: wait for all streams to complete, emit an array
+ * of their final values. If any stream completes without emitting,
+ * the result completes without emitting.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Wait for all streams to complete, then emit an array of their final values.
+ * If any stream completes without emitting, the result completes empty.
+ */
+export declare const forkJoin: <A, E>(...events: Event<A, E>[]) => Event<A[], E>;
+//# sourceMappingURL=forkJoin.d.ts.map

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

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

package/dist/combinators/fromPromise.d.ts

@@ -0,0 +1,17 @@
+/**
+ * fromPromise constructor.
+ *
+ * Denotation: `fromPromise(p) = [(t_resolve, value)]` or `Error(rejection)`
+ * where `t_resolve` is the time at which the promise settles.
+ */
+import type { Event } from "aeon-types";
+/**
+ * Create an Event from a Promise.
+ *
+ * The event emits the resolved value at the time the promise settles,
+ * then ends. If the promise rejects, the event errors.
+ *
+ * Denotation: `[(t_resolve, value)]` or `Error(rejection)`
+ */
+export declare const fromPromise: <A>(promise: Promise<A>) => Event<A, unknown>;
+//# sourceMappingURL=fromPromise.d.ts.map

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

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