@typed/fx 2.0.0-beta.3 → 2.0.0-beta.5

package/dist/Fx/combinators/slice.js

@@ -6,6 +6,22 @@ import { unwrap } from "./unwrap.js";
 /**
  * Slices an Fx by skipping a number of elements and then taking a number of elements.
  *
+ * @remarks
+ * ## Why
+ * `slice` expresses prefix omission and bounded output in one counter. It retains source order,
+ * emits at most `take` values after `skip`, and completes early once that bound is reached.
+ *
+ * ## Ownership and lifetime
+ * Counters are local to one run. Early completion stops upstream work; otherwise source failure,
+ * services, and consumer interruption are forwarded.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const page = Fx.fromIterable([1, 2, 3, 4]).pipe(Fx.slice({ skip: 1, take: 2 }))
+ * ```
+ *
  * @param bounds - The `Bounds` specifying how many elements to skip and take.
  * @returns An `Fx` representing the slice.
  * @since 1.0.0
@@ -15,6 +31,23 @@ export const slice = dual(2, (fx, bounds) => make((sink) => sinkCore.slice(sink,
 /**
  * Slices an Fx with bounds produced by an Effect.
  *
+ * @remarks
+ * ## Why
+ * `sliceEffect` delays selection of the bounds until consumption, allowing configuration to fail or
+ * require services before the source is subscribed.
+ *
+ * ## Ownership and lifetime
+ * The bounds Effect runs once per consumer. If it fails or is interrupted the source never starts;
+ * after success, ordinary `slice` owns only its per-run counters.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ *
+ * const page = Fx.fromIterable([1, 2, 3]).pipe(Fx.sliceEffect(Effect.succeed({ skip: 1, take: 1 })))
+ * ```
+ *
  * @param bounds - Effect that produces slice bounds.
  * @returns An `Fx` representing the slice.
  * @since 1.0.0

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

@@ -4,6 +4,44 @@ import type { FlatMapLike } from "./flatMap.js";
  *
  * When a new element is emitted, the previous inner Fx is cancelled.
  *
+ * @remarks
+ * ## Why
+ *
+ * `switchMap` models work whose result becomes obsolete when a newer source
+ * value arrives, such as suggestions for the current query. Cancellation is the
+ * policy: obsolete work is not allowed to finish in the background.
+ *
+ * ## Switching, ordering, and cardinality
+ *
+ * Every source value calls `f`. Before the new inner starts, the previous inner
+ * is interrupted and its interruption is awaited. Only the latest inner remains
+ * active; values it emitted before replacement remain visible, while later
+ * values from the replaced inner are suppressed. There is no result buffer.
+ *
+ * ## Ownership and lifetime
+ *
+ * Source and current-inner failures are forwarded and their services remain
+ * typed. The returned Fx requires `Scope`, which owns the current inner fiber.
+ * Source completion waits for the latest inner. Replacing or interrupting the
+ * output closes obsolete inner work and runs its scoped finalizers before the
+ * replacement proceeds.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * import { Effect } from "effect"
+ *
+ * const queries = Fx.mergeAll(
+ *   Fx.at("typed", "0 millis"),
+ *   Fx.at("typed fx", "5 millis")
+ * )
+ * const suggestions = Fx.switchMap(queries, (query) =>
+ *   Fx.ensuring(Fx.at(query, "20 millis"), Effect.log(`${query} closed`))
+ * )
+ * Effect.runPromise(Effect.scoped(Fx.collectAll(suggestions))).then(console.log)
+ * // logs cleanup for "typed" and resolves ["typed fx"]
+ * ```
+ *
  * @param f - A function that maps an element `A` to a new `Fx<B>`.
  * @returns An `Fx` that emits values from the latest inner stream.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"switchMap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/switchMap.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;GASG;AACH,eAAO,MAAM,SAAS,EAAE,WAgCvB,CAAC"}
+{"version":3,"file":"switchMap.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/switchMap.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,eAAO,MAAM,SAAS,EAAE,WAgCvB,CAAC"}

package/dist/Fx/combinators/switchMap.js

@@ -2,7 +2,7 @@ import * as Effect from "effect/Effect";
 import * as Fiber from "effect/Fiber";
 import { dual } from "effect/Function";
 import * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
+import * as Context from "effect/Context";
 import * as SyncronizedRef from "effect/SynchronizedRef";
 import { make as makeSink } from "../../Sink/Sink.js";
 import { make } from "../constructors/make.js";
@@ -12,16 +12,54 @@ import { extendScope } from "../internal/scope.js";
  *
  * When a new element is emitted, the previous inner Fx is cancelled.
  *
+ * @remarks
+ * ## Why
+ *
+ * `switchMap` models work whose result becomes obsolete when a newer source
+ * value arrives, such as suggestions for the current query. Cancellation is the
+ * policy: obsolete work is not allowed to finish in the background.
+ *
+ * ## Switching, ordering, and cardinality
+ *
+ * Every source value calls `f`. Before the new inner starts, the previous inner
+ * is interrupted and its interruption is awaited. Only the latest inner remains
+ * active; values it emitted before replacement remain visible, while later
+ * values from the replaced inner are suppressed. There is no result buffer.
+ *
+ * ## Ownership and lifetime
+ *
+ * Source and current-inner failures are forwarded and their services remain
+ * typed. The returned Fx requires `Scope`, which owns the current inner fiber.
+ * Source completion waits for the latest inner. Replacing or interrupting the
+ * output closes obsolete inner work and runs its scoped finalizers before the
+ * replacement proceeds.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * import { Effect } from "effect"
+ *
+ * const queries = Fx.mergeAll(
+ *   Fx.at("typed", "0 millis"),
+ *   Fx.at("typed fx", "5 millis")
+ * )
+ * const suggestions = Fx.switchMap(queries, (query) =>
+ *   Fx.ensuring(Fx.at(query, "20 millis"), Effect.log(`${query} closed`))
+ * )
+ * Effect.runPromise(Effect.scoped(Fx.collectAll(suggestions))).then(console.log)
+ * // logs cleanup for "typed" and resolves ["typed fx"]
+ * ```
+ *
  * @param f - A function that maps an element `A` to a new `Fx<B>`.
  * @returns An `Fx` that emits values from the latest inner stream.
  * @since 1.0.0
  * @category combinators
  */
 export const switchMap = dual(2, (self, f) => make(Effect.fn(function* (sink) {
-    const ctx = yield* Effect.services();
-    const scope = ServiceMap.get(ctx, Scope.Scope);
+    const ctx = yield* Effect.context();
+    const scope = Context.get(ctx, Scope.Scope);
     const fiberRef = yield* SyncronizedRef.make(null);
-    const next = (value) => Effect.forkIn(Effect.provideServices(f(value).run(sink), ctx), scope, {
+    const next = (value) => Effect.forkIn(Effect.provideContext(f(value).run(sink), ctx), scope, {
         startImmediately: false,
         uninterruptible: false,
     });

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

@@ -4,6 +4,43 @@ import type { FlatMapEffectLike } from "./flatMapEffect.js";
  *
  * When a new element is emitted, the previous effect is cancelled.
  *
+ * @remarks
+ * ## Why
+ *
+ * This is the Effect-producing form of {@link switchMap}. It makes latest-only
+ * Effect execution explicit without wrapping callbacks with `Fx.fromEffect`.
+ *
+ * ## Switching and cardinality
+ *
+ * Every source value creates one callback Effect. A new value interrupts and
+ * awaits the previous Effect before starting its replacement. Each Effect can
+ * emit one successful result, but an interrupted Effect may emit none.
+ *
+ * ## Ownership and lifetime
+ *
+ * Source and current callback failures remain typed and callback services are
+ * added to requirements. The required `Scope` owns the current Effect. Source
+ * completion waits for it; replacement and output interruption run its
+ * finalizers before relinquishing the lifetime.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * import { Effect } from "effect"
+ *
+ * const queries = Fx.mergeAll(
+ *   Fx.at("a", "0 millis"),
+ *   Fx.at("ab", "5 millis")
+ * )
+ * const result = Fx.switchMapEffect(queries, (query) =>
+ *   Effect.as(Effect.sleep("20 millis"), query).pipe(
+ *     Effect.ensuring(Effect.log(`${query} closed`))
+ *   )
+ * )
+ * Effect.runPromise(Effect.scoped(Fx.collectAll(result))).then(console.log)
+ * // ["ab"]
+ * ```
+ *
  * @param f - A function that maps an element `A` to an `Effect<B>`.
  * @returns An `Fx` that emits the results of the latest effect.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"switchMapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/switchMapEffect.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,iBAM7B,CAAC"}
+{"version":3,"file":"switchMapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/switchMapEffect.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAG5D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,eAAO,MAAM,eAAe,EAAE,iBAM7B,CAAC"}

package/dist/Fx/combinators/switchMapEffect.js

@@ -6,6 +6,43 @@ import { switchMap } from "./switchMap.js";
  *
  * When a new element is emitted, the previous effect is cancelled.
  *
+ * @remarks
+ * ## Why
+ *
+ * This is the Effect-producing form of {@link switchMap}. It makes latest-only
+ * Effect execution explicit without wrapping callbacks with `Fx.fromEffect`.
+ *
+ * ## Switching and cardinality
+ *
+ * Every source value creates one callback Effect. A new value interrupts and
+ * awaits the previous Effect before starting its replacement. Each Effect can
+ * emit one successful result, but an interrupted Effect may emit none.
+ *
+ * ## Ownership and lifetime
+ *
+ * Source and current callback failures remain typed and callback services are
+ * added to requirements. The required `Scope` owns the current Effect. Source
+ * completion waits for it; replacement and output interruption run its
+ * finalizers before relinquishing the lifetime.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * import { Effect } from "effect"
+ *
+ * const queries = Fx.mergeAll(
+ *   Fx.at("a", "0 millis"),
+ *   Fx.at("ab", "5 millis")
+ * )
+ * const result = Fx.switchMapEffect(queries, (query) =>
+ *   Effect.as(Effect.sleep("20 millis"), query).pipe(
+ *     Effect.ensuring(Effect.log(`${query} closed`))
+ *   )
+ * )
+ * Effect.runPromise(Effect.scoped(Fx.collectAll(result))).then(console.log)
+ * // ["ab"]
+ * ```
+ *
  * @param f - A function that maps an element `A` to an `Effect<B>`.
  * @returns An `Fx` that emits the results of the latest effect.
  * @since 1.0.0

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

@@ -3,6 +3,22 @@ import type { Fx } from "../Fx.js";
 /**
  * Takes the first `n` elements from an Fx and then completes.
  *
+ * @remarks
+ * ## Why
+ * `take` bounds cardinality without buffering: it forwards at most the first `n` values in order and
+ * then completes the run early.
+ *
+ * ## Ownership and lifetime
+ * A per-run counter owns no external resource. Reaching the limit interrupts/stops upstream work;
+ * source failures before that point and consumer interruption remain observable.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const firstTwo = Fx.fromIterable([1, 2, 3]).pipe(Fx.take(2))
+ * ```
+ *
  * @param n - The number of elements to take.
  * @returns An `Fx` that emits at most `n` elements.
  * @since 1.0.0
@@ -15,6 +31,22 @@ export declare const take: {
 /**
  * Takes the first `n` elements where `n` is produced by an Effect.
  *
+ * @remarks
+ * ## Why
+ * `takeEffect` obtains a dynamic bound once before subscribing, then applies ordinary `take`.
+ *
+ * ## Ownership and lifetime
+ * The count Effect can fail, require services, or be interrupted; in those cases upstream never
+ * starts. After success, reaching the limit stops upstream work.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ *
+ * const first = Fx.fromIterable([1, 2]).pipe(Fx.takeEffect(Effect.succeed(1)))
+ * ```
+ *
  * @param count - Effect that produces the number of elements to take.
  * @returns An `Fx` that emits at most `n` elements.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAInC;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAEvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAC6C,CAAC;AAEnG;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,EAAE,EAAE,EAAE,EACL,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GACnC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAKjG,CAAC"}
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAInC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAEvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAC6C,CAAC;AAEnG;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,EAAE,EAAE,EAAE,EACL,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GACnC,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACvD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAKjG,CAAC"}

package/dist/Fx/combinators/take.js

@@ -5,6 +5,22 @@ import { unwrap } from "./unwrap.js";
 /**
  * Takes the first `n` elements from an Fx and then completes.
  *
+ * @remarks
+ * ## Why
+ * `take` bounds cardinality without buffering: it forwards at most the first `n` values in order and
+ * then completes the run early.
+ *
+ * ## Ownership and lifetime
+ * A per-run counter owns no external resource. Reaching the limit interrupts/stops upstream work;
+ * source failures before that point and consumer interruption remain observable.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const firstTwo = Fx.fromIterable([1, 2, 3]).pipe(Fx.take(2))
+ * ```
+ *
  * @param n - The number of elements to take.
  * @returns An `Fx` that emits at most `n` elements.
  * @since 1.0.0
@@ -14,6 +30,22 @@ export const take = dual(2, (fx, n) => slice(fx, { skip: 0, take: n }));
 /**
  * Takes the first `n` elements where `n` is produced by an Effect.
  *
+ * @remarks
+ * ## Why
+ * `takeEffect` obtains a dynamic bound once before subscribing, then applies ordinary `take`.
+ *
+ * ## Ownership and lifetime
+ * The count Effect can fail, require services, or be interrupted; in those cases upstream never
+ * starts. After success, reaching the limit stops upstream work.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ *
+ * const first = Fx.fromIterable([1, 2]).pipe(Fx.takeEffect(Effect.succeed(1)))
+ * ```
+ *
  * @param count - Effect that produces the number of elements to take.
  * @returns An `Fx` that emits at most `n` elements.
  * @since 1.0.0

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

@@ -4,6 +4,21 @@ import type { Fx } from "../Fx.js";
  * Takes elements from an Fx until a predicate returns true.
  * The element that satisfies the predicate is not included in the output.
  *
+ * @remarks
+ * ## Why
+ * `takeUntil` forwards the ordered prefix before the first match, then completes without emitting
+ * the matching value.
+ *
+ * ## Ownership and lifetime
+ * Matching triggers the sink's early-exit path, stopping upstream work. No resources are acquired;
+ * earlier failures and consumer interruption remain observable.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const beforeThree = Fx.fromIterable([1, 2, 3]).pipe(Fx.takeUntil((n) => n === 3))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that completes when the predicate matches.
  * @since 1.0.0
@@ -17,6 +32,22 @@ export declare const takeUntil: {
  * Takes elements from an Fx until an effectful predicate returns true.
  * The element that satisfies the predicate is not included in the output.
  *
+ * @remarks
+ * ## Why
+ * `takeUntilEffect` makes the stopping decision Effectful and ordered. A successful match completes
+ * before that input is emitted; a false result forwards it.
+ *
+ * ## Ownership and lifetime
+ * Predicate effects run in the consumer and expose their failures and services. A match or
+ * interruption stops upstream and cancels active work.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([1, 2]).pipe(Fx.takeUntilEffect((n) => Effect.succeed(n === 2)))
+ * ```
+ *
  * @param predicate - Effectful predicate function.
  * @returns An `Fx` that completes when the predicate matches.
  * @since 1.0.0
@@ -30,6 +61,21 @@ export declare const takeUntilEffect: {
  * Drops elements from an Fx after a predicate returns true.
  * The element that satisfies the predicate is included in the output.
  *
+ * @remarks
+ * ## Why
+ * `dropAfter` includes the first matching value and then completes, giving an inclusive stopping
+ * boundary while preserving the preceding source order.
+ *
+ * ## Ownership and lifetime
+ * The match stops upstream through the early-exit sink. The operation acquires no external
+ * resource and preserves source failures and services before completion.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const throughTwo = Fx.fromIterable([1, 2, 3]).pipe(Fx.dropAfter((n) => n === 2))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that stops emitting when the predicate matches.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"takeUntil.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/takeUntil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CActE,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAmB1B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKvE,CAAC"}
+{"version":3,"file":"takeUntil.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/takeUntil.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAKxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CActE,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAmB1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAGvE,CAAC"}

package/dist/Fx/combinators/takeUntil.js

@@ -7,6 +7,21 @@ import { make as makeFx } from "../constructors/make.js";
  * Takes elements from an Fx until a predicate returns true.
  * The element that satisfies the predicate is not included in the output.
  *
+ * @remarks
+ * ## Why
+ * `takeUntil` forwards the ordered prefix before the first match, then completes without emitting
+ * the matching value.
+ *
+ * ## Ownership and lifetime
+ * Matching triggers the sink's early-exit path, stopping upstream work. No resources are acquired;
+ * earlier failures and consumer interruption remain observable.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const beforeThree = Fx.fromIterable([1, 2, 3]).pipe(Fx.takeUntil((n) => n === 3))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that completes when the predicate matches.
  * @since 1.0.0
@@ -24,6 +39,22 @@ export const takeUntil = dual(2, (fx, predicate) => {
  * Takes elements from an Fx until an effectful predicate returns true.
  * The element that satisfies the predicate is not included in the output.
  *
+ * @remarks
+ * ## Why
+ * `takeUntilEffect` makes the stopping decision Effectful and ordered. A successful match completes
+ * before that input is emitted; a false result forwards it.
+ *
+ * ## Ownership and lifetime
+ * Predicate effects run in the consumer and expose their failures and services. A match or
+ * interruption stops upstream and cancels active work.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([1, 2]).pipe(Fx.takeUntilEffect((n) => Effect.succeed(n === 2)))
+ * ```
+ *
  * @param predicate - Effectful predicate function.
  * @returns An `Fx` that completes when the predicate matches.
  * @since 1.0.0
@@ -37,6 +68,21 @@ export const takeUntilEffect = dual(2, (fx, predicate) => makeFx((sink) => combi
  * Drops elements from an Fx after a predicate returns true.
  * The element that satisfies the predicate is included in the output.
  *
+ * @remarks
+ * ## Why
+ * `dropAfter` includes the first matching value and then completes, giving an inclusive stopping
+ * boundary while preserving the preceding source order.
+ *
+ * ## Ownership and lifetime
+ * The match stops upstream through the early-exit sink. The operation acquires no external
+ * resource and preserves source failures and services before completion.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const throughTwo = Fx.fromIterable([1, 2, 3]).pipe(Fx.dropAfter((n) => n === 2))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that stops emitting when the predicate matches.
  * @since 1.0.0

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

@@ -4,6 +4,21 @@ import type { Fx } from "../Fx.js";
  * Takes elements from an Fx while a predicate returns true.
  * Stops at the first element for which the predicate returns false; that element is not included.
  *
+ * @remarks
+ * ## Why
+ * `takeWhile` emits the longest matching prefix, in order, and completes before the first false
+ * value. It is the predicate complement of `takeUntil`.
+ *
+ * ## Ownership and lifetime
+ * A false result stops upstream immediately. The pure predicate acquires no resources and adds no
+ * failures or services.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const small = Fx.fromIterable([1, 2, 3]).pipe(Fx.takeWhile((n) => n < 3))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that emits while the predicate holds.
  * @since 1.0.0
@@ -17,6 +32,22 @@ export declare const takeWhile: {
  * Takes elements from an Fx while an effectful predicate returns true.
  * Stops at the first element for which the predicate effect succeeds with false; that element is not included.
  *
+ * @remarks
+ * ## Why
+ * `takeWhileEffect` performs the prefix decision with Effect and completes before the first false
+ * value, retaining source order.
+ *
+ * ## Ownership and lifetime
+ * Predicate effects expose their failures and services and are interrupted with the run. A false
+ * result stops upstream; no independent fiber or buffer is retained.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const small = Fx.fromIterable([1, 2]).pipe(Fx.takeWhileEffect((n) => Effect.succeed(n < 2)))
+ * ```
+ *
  * @param predicate - Effectful predicate function.
  * @returns An `Fx` that emits while the predicate holds.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"takeWhile.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/takeWhile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKvE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAO1B,CAAC"}
+{"version":3,"file":"takeWhile.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/takeWhile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,SAAS,EAAE;IACtB,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1E,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAGvE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,eAAe,EAAE;IAC5B,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EACR,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACpD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GAClD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAO1B,CAAC"}

package/dist/Fx/combinators/takeWhile.js

@@ -5,6 +5,21 @@ import { takeUntil, takeUntilEffect } from "./takeUntil.js";
  * Takes elements from an Fx while a predicate returns true.
  * Stops at the first element for which the predicate returns false; that element is not included.
  *
+ * @remarks
+ * ## Why
+ * `takeWhile` emits the longest matching prefix, in order, and completes before the first false
+ * value. It is the predicate complement of `takeUntil`.
+ *
+ * ## Ownership and lifetime
+ * A false result stops upstream immediately. The pure predicate acquires no resources and adds no
+ * failures or services.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const small = Fx.fromIterable([1, 2, 3]).pipe(Fx.takeWhile((n) => n < 3))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that emits while the predicate holds.
  * @since 1.0.0
@@ -15,6 +30,22 @@ export const takeWhile = dual(2, (fx, predicate) => takeUntil(fx, (a) => !predic
  * Takes elements from an Fx while an effectful predicate returns true.
  * Stops at the first element for which the predicate effect succeeds with false; that element is not included.
  *
+ * @remarks
+ * ## Why
+ * `takeWhileEffect` performs the prefix decision with Effect and completes before the first false
+ * value, retaining source order.
+ *
+ * ## Ownership and lifetime
+ * Predicate effects expose their failures and services and are interrupted with the run. A false
+ * result stops upstream; no independent fiber or buffer is retained.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const small = Fx.fromIterable([1, 2]).pipe(Fx.takeWhileEffect((n) => Effect.succeed(n < 2)))
+ * ```
+ *
  * @param predicate - Effectful predicate function.
  * @returns An `Fx` that emits while the predicate holds.
  * @since 1.0.0

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

@@ -3,6 +3,22 @@ import type { Fx } from "../Fx.js";
 /**
  * Performs an effect for each element of the Fx, without changing the elements.
  *
+ * @remarks
+ * ## Why
+ * `tap` sequences an observation or side effect before forwarding each original value. It emits
+ * exactly once per successful callback, in source order; callback failure prevents that value.
+ *
+ * ## Ownership and lifetime
+ * Returned Effects run in the consumer path and are interrupted with it; a `void` callback is
+ * treated as `Effect.void`. Callback failures and services remain visible in the result type.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const logged = Fx.fromIterable([1, 2]).pipe(Fx.tap((n) => Effect.log(n)))
+ * ```
+ *
  * @param f - An effectful function to apply to each element.
  * @returns An `Fx` that emits the original elements.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"tapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/tapEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB,CAAC,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EACxB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GACjD,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAE3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC9B,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GACjD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAgB1B,CAAC"}
+{"version":3,"file":"tapEffect.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/tapEffect.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,GAAG,EAAE;IAChB,CAAC,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EACxB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GACjD,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAE3D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC9B,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,EACtB,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,GACjD,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAgB1B,CAAC"}

package/dist/Fx/combinators/tapEffect.js

@@ -5,6 +5,22 @@ import { make } from "../constructors/make.js";
 /**
  * Performs an effect for each element of the Fx, without changing the elements.
  *
+ * @remarks
+ * ## Why
+ * `tap` sequences an observation or side effect before forwarding each original value. It emits
+ * exactly once per successful callback, in source order; callback failure prevents that value.
+ *
+ * ## Ownership and lifetime
+ * Returned Effects run in the consumer path and are interrupted with it; a `void` callback is
+ * treated as `Effect.void`. Callback failures and services remain visible in the result type.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const logged = Fx.fromIterable([1, 2]).pipe(Fx.tap((n) => Effect.log(n)))
+ * ```
+ *
  * @param f - An effectful function to apply to each element.
  * @returns An `Fx` that emits the original elements.
  * @since 1.0.0