@typed/fx 1.32.0 → 2.0.0-beta.1

package/README.md

@@ -1,5 +1,370 @@
 # @typed/fx
 
-> WIP
+> **Beta:** This package is in beta; APIs may change.
 
-Docs: https://tylors.github.io/typed/docs/fx
+`@typed/fx` provides reactive streams and state for Effect: **Fx** (streams with rich combinators and run functions), **Push**, **RefSubject** (and typed refs like RefArray, RefBoolean), **Subject**, **Sink**, and **Versioned**. Use it for event streams, reactive UI state, and composing effects as streams.
+
+## Dependencies
+
+- `effect`
+
+## API overview
+
+- **Fx** — Stream type `Fx.Fx<A, E, R>` with constructors (`succeed`, `fail`, `fromEffect`, `fromIterable`, `make`, `periodic`, etc.), combinators (`map`, `flatMap`, `filter`, `take`, `switchMap`, etc.), and run (`runPromise`, `collect`, `fork`, `observe`).
+- **Push** — Push-based stream abstraction.
+- **RefSubject** — Mutable reactive refs; `RefSubject.make(initial)`; typed helpers like `RefSubject.increment` / `RefSubject.decrement` for numbers; `RefArray`, `RefBoolean`, `RefOption`, etc.
+- **Subject** — Multicast subject for Fx streams.
+- **Sink** — Consumer abstraction with combinators.
+- **Versioned** — Versioned values.
+
+## Example
+
+```ts
+import { Fx } from "@typed/fx";
+
+Fx.fromIterable([1, 2, 3]).pipe(
+  Fx.filter((n) => n % 2 === 0),
+  Fx.map((n) => n * 2),
+  Fx.observe((n) => Effect.log(`emitted: ${n}`)),
+  Effect.runPromise,
+);
+```
+
+See the [counter example](https://github.com/typed-smol/typed-smol/tree/main/examples/counter) for a full runnable app.
+
+## API reference
+
+- [Fx](#fx)
+- [Push](#push)
+- [RefSubject](#refsubject)
+- [Subject](#subject)
+- [Sink](#sink)
+- [Versioned](#versioned)
+
+### Fx
+
+Reactive stream type with concurrency, error handling, and context, integrated with Effect.
+
+**Type**
+
+- `Fx<A, E, R>` — Stream that emits `A`, can fail with `E`, requires context `R`; has `.run(sink)`.
+
+**Type-level**
+
+- `Fx.Success<T>`, `Fx.Error<T>`, `Fx.Services<T>` — Extract success, error, and context from an Fx type.
+- `Fx.Any`, `Fx.Variance` — Wildcard and variance markers.
+- `Fx.Service`, `Fx.Class` — Dependency-injection service/class for Fx.
+
+**Constructors**
+
+- `succeed(value)` — Emit a single value and complete.
+- `succeedNull` / `null` — Emit `null` and complete.
+- `succeedUndefined` / `undefined` — Emit `undefined` and complete.
+- `succeedVoid` / `void` — Emit void and complete.
+- `fail(error)` — Fail immediately with an error.
+- `failCause(cause)` — Fail immediately with a Cause.
+- `die(defect)` — Terminate with a defect.
+- `interrupt(id?)` — Create an Fx that interrupts.
+- `empty` — Emit nothing and complete immediately.
+- `never` — Run forever without emitting.
+- `fromEffect(effect)` — One-value Fx from an Effect (emit on success, fail on failure).
+- `fromIterable(iterable)` — Emit each element of the iterable then complete.
+- `fromYieldable(yieldable)` — Fx from any Yieldable (Effect, Promise, etc.).
+- `fromSchedule(schedule)` — Emit `void` each time the schedule fires.
+- `fromFailures(failures)` — Fx that fails with combined failures from an iterable.
+- `make(run)` — Low-level: build Fx from a function that runs a Sink.
+- `callback(run)` — Build Fx from a callback; receives `Emit` (succeed, failCause, fail, die, done).
+- `at(value, delay)` — Emit one value after a delay.
+- `periodic(period)` — Emit `void` on a fixed interval.
+- `fn(body, ...pipeables)` — Effect.fn-style for Fx (body can return Fx); optional name/span.
+
+**Combinators**
+
+- `map(f)` — Transform emitted values.
+- `mapEffect(f)` — Transform with an Effect.
+- `mapError(f)` — Transform typed failures.
+- `mapBoth({ onSuccess, onFailure })` — Transform both success values and typed failures.
+- `flatMap(f)` — Map to inner Fx and merge (concurrent; like mergeMap).
+- `flatMapEffect(f)` — FlatMap with an Effect returning Fx.
+- `flatMapConcurrently(f, concurrency?)` — FlatMap with a concurrency limit.
+- `flatMapConcurrentlyEffect(f, concurrency?)` — Same with Effect-based inner Fx.
+- `switchMap(f)` — Map to inner Fx and switch to latest (cancels previous).
+- `switchMapEffect(f)` — SwitchMap with Effect returning Fx.
+- `exhaustMap(f)` — Map to inner Fx, ignore new outer values while inner runs.
+- `exhaustMapEffect(f)` — ExhaustMap with Effect returning Fx.
+- `exhaustLatestMap(f)` — Like exhaustMap but cancel previous inner when new outer arrives.
+- `exhaustLatestMapEffect(f)` — ExhaustLatestMap with Effect returning Fx.
+- `filter(f)` — Keep only values satisfying the predicate.
+- `filterEffect(f)` — Filter with an Effect predicate.
+- `filterMap(f)` — Filter and map to Option; compact.
+- `filterMapEffect(f)` — FilterMap with Effect.
+- `compact` — Filter out `None`, unwrap `Some`.
+- `take(n)` — Take first n elements.
+- `takeEffect(effect)` — Take first n elements, where n is computed by an Effect.
+- `takeUntil(fx)` — Take until another Fx emits.
+- `takeUntilEffect(f)` — Take until an effectful predicate returns true.
+- `takeWhile(f)` — Take while predicate holds.
+- `takeWhileEffect(f)` — Take while effectful predicate holds.
+- `skip(n)` — Skip first n elements.
+- `skipEffect(effect)` — Skip first n elements, where n is computed by an Effect.
+- `skipWhile(f)` / `dropWhile(f)` — Skip while predicate holds.
+- `skipWhileEffect(f)` / `dropWhileEffect(f)` — Skip while effectful predicate holds.
+- `slice(options)` — Skip/take by bounds.
+- `sliceEffect(effect)` — Skip/take by bounds produced by an Effect.
+- `skipRepeats` — Drop consecutive duplicates (Equal).
+- `skipRepeatsWith(equiv)` — Drop consecutive duplicates with custom equivalence.
+- `changesWithEffect(f)` — Effectful consecutive deduplication predicate.
+- `merge(fx)` — Merge with another Fx.
+- `mergeAll(fxs)` — Merge multiple Fx streams.
+- `mergeOrdered(fxs)` — Merge with ordering guarantees.
+- `concat(fx)` — Concatenate with another Fx (run second after first completes).
+- `zip(fx)` / `zipWith(fx, f)` — Zip streams in lockstep.
+- `zipLatest(fx)` / `zipLatestWith(fx, f)` — Zip latest values after both emit once.
+- `catch(f)` — Recover from errors.
+- `catchIf(refinement, f)` — Recover conditionally from typed failures.
+- `catchCauseIf(predicate, f)` — Recover conditionally from failure causes.
+- `catchTags(handlers)` — Recover from multiple tagged failures with handler map.
+- `onError(f)` — Run an effect on failure.
+- `onExit(f)` — Run an effect on exit (success/failure/interrupt).
+- `onInterrupt(f)` — Run an effect on interrupt.
+- `ensuring(effect)` — Run effect when Fx ends (success, failure, or interrupt).
+- `provide(services)` — Provide context to the Fx.
+- `provideService(tag, service)` — Provide a single service to the Fx.
+- `provideServiceEffect(tag, effect)` — Provide a service produced by an Effect.
+- `when(condition, fx)` — Run Fx only when condition holds.
+- `unwrap` — Unwrap Fx of Fx (flatten one level).
+- `unwrapScoped` — Unwrap with Scope for inner Fx.
+- `gen(f)` — Build Fx from a generator (yield Effects, return Fx).
+- `genScoped(f)` — gen with Scope.
+- `loop(initial, f)` — Loop with state and Option for continue/exit.
+- `loopEffect(initial, f)` — Loop with Effect.
+- `scan(initial, f)` — Emit running accumulation (includes initial value).
+- `scanEffect(initial, f)` — Effectful running accumulation.
+- `loopCause(initial, f)` — Loop with Cause handling.
+- `loopCauseEffect(initial, f)` — Loop with Cause and Effect.
+- `filterMapLoop(initial, f)` — Loop yielding Option.
+- `filterMapLoopEffect(initial, f)` — filterMapLoop with Effect.
+- `filterMapLoopCause(initial, f)` — filterMapLoop with Cause.
+- `filterMapLoopCauseEffect(initial, f)` — filterMapLoop with Cause and Effect.
+- `keyed(keyFn, f)` — Keyed stream (e.g. by id) with inner Fx per key.
+- `tapEffect(f)` — Run effect for each value, pass value through.
+- `exit` — Turn Fx of Exit into Fx that fails/succeeds accordingly.
+- `result` — Materialize successes/failures as `Result`.
+- `causes` — Expose failures as Cause emissions.
+- `continueWith(f)` — When Fx ends, continue with another Fx.
+- `flip` — Swap success and error types.
+- `tuple(...fxs)` — Combine Fx streams into tuple Fx.
+- `withSpan(name?, options?)` — Add tracing span around the Fx.
+
+**Run**
+
+- `runPromise(fx, options?)` — Run to completion; Promise rejects on failure.
+- `runPromiseExit(fx, options?)` — Run to completion; Promise resolves to Exit.
+- `collectAll(fx)` — Collect all emitted values into an array (Effect).
+- `collectAllFork(fx)` — Fork collection of all values (returns Fiber of array).
+- `collectUpTo(fx, n)` — Collect at most n values.
+- `collectUpToFork(fx, n)` — Fork collectUpTo.
+- `first(fx)` — Effect that yields first value as Option (None if empty).
+- `fork(fx, options?)` — Run Fx in a background fiber; returns Effect of Fiber.
+- `runFork(fx, options?)` — Run Fx in a new fiber via Effect.runFork.
+- `observe(fx, f)` — Run callback for each value; returns Effect that completes when stream ends.
+- `drain(fx)` — Run Fx, discard values (Effect completes when stream ends).
+- `drainLayer(fx)` — Layer that forks and drains the Fx.
+- `observeLayer(fx, f)` — Layer that observes the Fx with the given callback.
+
+**Stream interop**
+
+- `toStream(fx, options?)` — Convert Fx to Effect Stream.
+- `fromStream(stream, options?)` — Convert Effect Stream to Fx.
+
+---
+
+### Push
+
+Push-based abstraction that is both a Sink (input) and an Fx (output).
+
+**Type**
+
+- `Push<A, E, R, B, E2, R2>` — Consumes `A` (Sink) and produces `B` (Fx); input and output types are independent.
+
+**Constructor**
+
+- `Push.make(sink, fx)` — Create a Push from a Sink and an Fx (dual: can be called as `make(fx)(sink)`).
+
+**Service**
+
+- `Push.Service`, `Push.Class` — Dependency-injection for Push.
+
+---
+
+### RefSubject
+
+Mutable reactive reference: observable state that can be read (as Effect), updated, and subscribed to (as Fx).
+
+**Types**
+
+- `RefSubject<A, E, R>` — Mutable ref; extends `Computed` and `Subject`; has `updates(transaction)` and `interrupt`.
+- `Computed<A, E, R>` — Read-only derived value (Fx + Effect); emits and samples transformed value.
+- `Filtered<A, E, R>` — Computed over Option; may not always have a value.
+- `GetSetDelete<A, E, R>` — Interface with get/set/delete for use inside `updates`.
+
+**Constructors**
+
+- `make(initial, options?)` — Create RefSubject from value, Effect, or Fx; options include `eq` (equivalence).
+- `fromEffect(effect)` — RefSubject driven by an Effect (e.g. initial value from async source).
+- `fromFx(fx)` — RefSubject that follows an Fx stream.
+- `fromStream(stream)` — RefSubject from an Effect Stream.
+
+**Core operations**
+
+- `set(ref, value)` — Set current value.
+- `reset(ref)` — Reset to initial (if any); returns previous value as Option.
+- `update(ref, f)` — Update with a pure function.
+- `updateEffect(ref, f)` — Update with an Effect.
+- `modify(ref, f)` — Modify and return a result (pure).
+- `modifyEffect(ref, f)` — Modify with an Effect.
+- `runUpdates(ref, f)` — Run an effect that can read/update the ref (transactional).
+- `increment(ref)` — Add 1 to a number RefSubject; returns new value.
+- `decrement(ref)` — Subtract 1 from a number RefSubject; returns new value.
+- `proxy(ref)` — Create a proxy RefSubject that forwards to the given ref.
+- `isRefSubject(value)` — Type guard for RefSubject.
+
+**Derived**
+
+- `map(ref, f)` — Computed that applies f to the value.
+- `mapEffect(ref, f)` — Computed with Effect transformation.
+- `filterMap(ref, f)` — Filtered computed (Option).
+- `filterMapEffect(ref, f)` — FilterMap with Effect.
+- `compact(ref)` — Filtered that strips Option.
+- `slice(ref, options)` — Slice over iterable-like ref.
+- `transform(ref, transformFx, transformGet)` — General transform of a RefSubject/Versioned.
+- `makeComputed(input, f)` — Build a Computed from a Versioned and an Effect function.
+- `makeFiltered(input, f)` — Build a Filtered from a Versioned and an Effect returning Option.
+- `struct(refs)` — Combine refs into a struct RefSubject.
+- `tuple(refs)` — Combine refs into a tuple RefSubject.
+- `computedFromService(service)`, `filteredFromService(service)` — Computed/Filtered from a service.
+
+**Typed refs** (each has `make` and domain-specific helpers)
+
+- `RefArray` — Array ref; e.g. prepend, append, remove.
+- `RefBoolean` — Boolean ref; e.g. toggle, setTrue, setFalse.
+- `RefOption` — Option ref.
+- `RefResult` — Result ref.
+- `RefString` — String ref.
+- `RefBigInt` — BigInt ref.
+- `RefBigDecimal` — BigDecimal ref.
+- `RefDuration` — Duration ref.
+- `RefDateTime` — DateTime ref.
+- `RefCause` — Cause ref.
+- `RefChunk` — Chunk ref.
+- `RefHashMap` — HashMap ref.
+- `RefHashSet` — HashSet ref.
+- `RefRecord` — Record ref.
+- `RefStruct` — Struct ref.
+- `RefTuple` — Tuple ref.
+- `RefGraph` — Graph ref.
+- `RefHashRing` — HashRing ref.
+- `RefTrie` — Trie ref.
+- `RefIterable` — Iterable ref.
+
+---
+
+### Subject
+
+Multicast point: both an Fx and a Sink; multiple subscribers share one run of the source.
+
+**Type**
+
+- `Subject<A, E, R>` — Implements `Fx<A, E, R>` and `Sink<A, E, R>`; has `subscriberCount` (Effect) and `interrupt`.
+
+**Constructors**
+
+- `Subject.make(replay?)` — Create a subject; optional replay buffer size.
+- `Subject.unsafeMake(replay?)` — Create without Scope (unsafe for cleanup).
+
+**Combinators**
+
+- `Subject.share(fx, subject)` — Multicast Fx through a subject (one run, many subscribers).
+- `Subject.multicast(fx)` — Share Fx with a fresh subject.
+- `Subject.hold(fx)` — Fx that holds last value for late subscribers.
+- `Subject.replay(fx, n)` — Replay last n values to new subscribers.
+
+**Service**
+
+- `Subject.Service`, `Subject.Class` — Dependency-injection for Subject.
+
+---
+
+### Sink
+
+Consumer of values: two callbacks, one for success and one for failure.
+
+**Type**
+
+- `Sink<A, E, R>` — `{ onSuccess: (value: A) => Effect, onFailure: (cause: Cause<E>) => Effect }`.
+- `Sink.WithEarlyExit<A, E, R>` — Adds `earlyExit` for early termination.
+- `Sink.WithState<A, E, R, B>` — Sink with state Ref.
+- `Sink.WithStateSemaphore<A, E, R, B>` — Sink with state and transactional updates.
+
+**Constructor**
+
+- `Sink.make(onFailure, onSuccess)` — Build a Sink from the two callbacks.
+
+**Combinators**
+
+- `map(sink, f)` — Transform values before they reach the sink.
+- `filterMap(sink, f)` — Filter and map (Option).
+- `compact(sink)` — Sink for Option, forward only Some.
+- `filter(sink, f)` — Filter values.
+- `withEarlyExit(sink, earlyExit)` — Add early-exit capability.
+- `withState(sink, initial, f)` — Stateful sink.
+- `withStateSemaphore(sink, initial, f)` — Stateful sink with semaphore for transactional updates.
+- `loop(sink, initial, f)` — Loop over sink with state.
+- `loopCause(sink, initial, f)` — Loop with Cause handling.
+- `filterMapLoop(sink, initial, f)` — Loop with filterMap.
+- `filterMapLoopCause(sink, initial, f)` — filterMapLoop with Cause.
+- `loopEffect(sink, initial, f)` — Loop with Effect.
+- `filterMapLoopEffect(sink, initial, f)` — filterMapLoop with Effect.
+- `loopCauseEffect(sink, initial, f)` — loopCause with Effect.
+- `filterMapLoopCauseEffect(sink, initial, f)` — Full variant with Cause and Effect.
+- `slice(sink, options)` — Skip/take at the Sink level.
+- `mapEffect(sink, f)` — Effectful map.
+- `filterMapEffect(sink, f)` — Effectful filterMap.
+- `filterEffect(sink, f)` — Effectful filter.
+- `tapEffect(sink, f)` — Tap with Effect, pass value through.
+- `flip(sink)` — Swap success and error types.
+- `exit(sink)` — Sink for Exit (success/failure).
+- `dropAfter(sink, n)` — Drop values after the nth.
+- `skipInterrupt(sink)` — Ignore interrupt at the Sink.
+
+**Service**
+
+- `Sink.Service`, `Sink.Class` — Dependency-injection for Sink.
+
+---
+
+### Versioned
+
+Value that changes over time with a version number; both an Fx (subscribe to changes) and an Effect (sample current value).
+
+**Type**
+
+- `Versioned<R1, E1, A2, E2, R2, A3, E3, R3>` — Fx emits `A2`; sampling yields `A3`; has `version` (Effect of number) and `interrupt`.
+
+**Type-level**
+
+- `Versioned.Unify<T>` — Unify a Versioned type.
+- `Versioned.VersionContext<T>` — Context required to get version.
+- `Versioned.VersionError<T>` — Error type of the version effect.
+
+**Constructor**
+
+- `Versioned.make(version, fx, effect)` — Build Versioned from version effect, update stream (Fx), and current-value effect.
+
+**Combinators**
+
+- `Versioned.transform(input, transformFx, transformGet)` — Transform the Fx and the sampling effect into a new Versioned.
+
+**Service**
+
+- `Versioned.Service`, `Versioned.Class` — Dependency-injection for Versioned.

package/dist/Fx/Fx.d.ts

@@ -0,0 +1,96 @@
+import * as Effect from "effect/Effect";
+import type { Layer } from "effect/Layer";
+import { type Pipeable } from "effect/Pipeable";
+import type * as Scope from "effect/Scope";
+import * as ServiceMap from "effect/ServiceMap";
+import type * as Types from "effect/Types";
+import type * as Sink from "../Sink/Sink.js";
+import { FxTypeId } from "./TypeId.js";
+/**
+ * `Fx` is a reactive stream of values that supports concurrency, error handling,
+ * and context management, fully integrated with the Effect ecosystem.
+ *
+ * Conceptually, an `Fx<A, E, R>` is a push-based stream that:
+ * - Emits values of type `A`
+ * - Can fail with an error of type `E`
+ * - Requires a context/environment of type `R`
+ *
+ * Unlike a standard `Effect` which produces a single value, `Fx` can produce
+ * 0, 1, or many values over time. It is similar to RxJS Observables or
+ * AsyncIterables, but built on top of Effect's fiber-based concurrency model.
+ *
+ * @since 1.0.0
+ * @category models
+ */
+export interface Fx<A, E = never, R = never> extends Pipeable {
+    readonly [FxTypeId]: Fx.Variance<A, E, R>;
+    /**
+     * Runs the Fx stream by providing a Sink to consume the values.
+     * The result is an Effect that runs the stream process.
+     */
+    readonly run: <RSink>(sink: Sink.Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>;
+}
+export declare namespace Fx {
+    /**
+     * Any Fx type with wildcards.
+     * @since 1.0.0
+     * @category models
+     */
+    type Any = Fx<any, any, any>;
+    /**
+     * Variance markers for Fx types.
+     * @since 1.0.0
+     * @category models
+     */
+    interface Variance<A, E, R> {
+        readonly _A: Types.Covariant<A>;
+        readonly _E: Types.Covariant<E>;
+        readonly _R: Types.Covariant<R>;
+    }
+    /**
+     * Extract the success type from an Fx.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Success<T> = [T] extends [never] ? never : T extends Fx<infer _A, infer _E, infer _R> ? _A : never;
+    /**
+     * Extract the error type from an Fx.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Error<T> = [T] extends [never] ? never : T extends Fx<infer _A, infer _E, infer _R> ? _E : never;
+    /**
+     * Extract the required services from an Fx.
+     * @since 1.0.0
+     * @category type-level
+     */
+    type Services<T> = [T] extends [never] ? never : [T] extends [Fx<infer _A, infer _E, infer _R>] ? _R : never;
+    interface Service<Self, Id extends string, A, E> extends Fx<A, E, Self> {
+        readonly id: Id;
+        readonly service: ServiceMap.Service<Self, Fx<A, E>>;
+        readonly make: <R = never>(fx: Fx<A, E, R> | Effect.Effect<Fx<A, E, R>, E, R>) => Layer<Self, E, Exclude<R, Scope.Scope>>;
+    }
+    interface Class<Self, Id extends string, A, E> extends Service<Self, Id, A, E> {
+        new (): Service<Self, Id, A, E>;
+    }
+}
+/**
+ * Extract the success type from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Success<T> = Fx.Success<T>;
+/**
+ * Extract the error type from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Error<T> = Fx.Error<T>;
+/**
+ * Extract the required services from an Fx.
+ * @since 1.0.0
+ * @category type-level
+ */
+export type Services<T> = Fx.Services<T>;
+export declare function Service<Self, A, E = never>(): <const Id extends string>(id: Id) => Fx.Class<Self, Id, A, E>;
+//# sourceMappingURL=Fx.d.ts.map

package/dist/Fx/Fx.d.ts.map

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

package/dist/Fx/Fx.js

@@ -0,0 +1,35 @@
+import * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import { effect } from "effect/Layer";
+import { pipeArguments } from "effect/Pipeable";
+import * as ServiceMap from "effect/ServiceMap";
+import { provideServices } from "./combinators/provide.js";
+import { FxTypeId, isFx } from "./TypeId.js";
+const VARIANCE = {
+    _A: identity,
+    _E: identity,
+    _R: identity,
+};
+export function Service() {
+    return (id) => {
+        const service = ServiceMap.Service(id);
+        // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+        return class FxService {
+            static id = id;
+            static service = service;
+            static make = (fx) => effect(service, Effect.gen(function* () {
+                const services = yield* Effect.services();
+                const result = isFx(fx) ? fx : yield* fx;
+                return provideServices(result, services);
+            }));
+            static [FxTypeId] = VARIANCE;
+            static pipe = function () {
+                return pipeArguments(this, arguments);
+            };
+            static run = (sink) => Effect.flatMap(service.asEffect(), (fx) => fx.run(sink));
+            constructor() {
+                return FxService;
+            }
+        };
+    };
+}

package/dist/Fx/TypeId.d.ts

@@ -0,0 +1,20 @@
+import type { Fx } from "./Fx.js";
+/**
+ * The unique type identifier for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export declare const FxTypeId: unique symbol;
+/**
+ * The unique type identifier type for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export type FxTypeId = typeof FxTypeId;
+/**
+ * Checks if a value is an Fx.
+ * @since 1.0.0
+ * @category guards
+ */
+export declare function isFx(u: unknown): u is Fx<any, any, any>;
+//# sourceMappingURL=TypeId.d.ts.map

package/dist/Fx/TypeId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TypeId.d.ts","sourceRoot":"","sources":["../../src/Fx/TypeId.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,SAAS,CAAC;AAElC;;;;GAIG;AACH,eAAO,MAAM,QAAQ,eAA6B,CAAC;AAEnD;;;;GAIG;AACH,MAAM,MAAM,QAAQ,GAAG,OAAO,QAAQ,CAAC;AAEvC;;;;GAIG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,CAAC,CAEvD"}

package/dist/Fx/TypeId.js

@@ -0,0 +1,15 @@
+import { hasProperty } from "effect/Predicate";
+/**
+ * The unique type identifier for Fx.
+ * @since 1.0.0
+ * @category symbol
+ */
+export const FxTypeId = Symbol.for("@typed/fx/Fx");
+/**
+ * Checks if a value is an Fx.
+ * @since 1.0.0
+ * @category guards
+ */
+export function isFx(u) {
+    return hasProperty(u, FxTypeId);
+}

package/dist/Fx/combinators/additive.d.ts

@@ -0,0 +1,94 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Merges two Fx streams into a single Fx that emits values from both streams
+ * concurrently. Order of emission is non-deterministic.
+ *
+ * **Completion:** The merged stream completes when **both** input streams have
+ * completed.
+ *
+ * **Errors:** The first failure from either stream fails the merged stream;
+ * the other stream is interrupted.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits values from both streams.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const merge: {
+    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A | A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A | A2, E | E2, R | R2>;
+};
+/**
+ * Concatenates two Fx streams: runs the first to completion, then runs the
+ * second. Emits all values from the first stream in order, then all values
+ * from the second stream in order.
+ *
+ * **Completion:** The concatenated stream completes when the **second** stream
+ * completes (the first must complete before the second starts).
+ *
+ * **Errors:** If the first stream fails, the concatenated stream fails and the
+ * second is never run. If the second stream fails, the concatenated stream
+ * fails after the first has already completed.
+ *
+ * @param that - The second Fx stream (run after the first completes).
+ * @returns An Fx that emits values from the first stream, then the second.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const concat: {
+    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A | A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A | A2, E | E2, R | R2>;
+};
+/**
+ * Zips two Fx streams in strict lockstep and emits only the left value.
+ * Completes when the **first** of the two streams completes.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits values from the left stream only.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const zipLeft: {
+    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A, E | E2, R | R2>;
+};
+/**
+ * Zips two Fx streams in strict lockstep and emits only the right value.
+ * Completes when the **first** of the two streams completes.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits values from the right stream only.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const zipRight: {
+    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A2, E | E2, R | R2>;
+};
+/**
+ * Merges two Fx streams and emits only values from the left stream.
+ * Both streams run concurrently; completion when **both** complete.
+ *
+ * @param that - The second Fx stream (values are dropped).
+ * @returns An Fx that emits only values from the left stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const mergeLeft: {
+    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A, E | E2, R | R2>;
+};
+/**
+ * Merges two Fx streams and emits only values from the right stream.
+ * Both streams run concurrently; completion when **both** complete.
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits only values from the right stream.
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const mergeRight: {
+    <A2, E2, R2>(that: Fx<A2, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A2, E | E2, R | R2>;
+    <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, that: Fx<A2, E2, R2>): Fx<A2, E | E2, R | R2>;
+};
+//# sourceMappingURL=additive.d.ts.map

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

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