@typed/fx 2.0.0-beta.1 → 2.0.0-beta.10

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

@@ -3,10 +3,26 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const take: {
     (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
@@ -15,10 +31,26 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const takeEffect: {
     <E2, R2>(count: Effect.Effect<number, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;

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,18 +5,50 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 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
- * @category combinators
+ * @category Selecting values
  */
 export const takeEffect = dual(2, (fx, count) => unwrap(Effect.map(count, (n) => take(fx, n))));

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

@@ -4,10 +4,25 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const takeUntil: {
     <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
@@ -17,10 +32,26 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const takeUntilEffect: {
     <A, E2, R2>(predicate: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
@@ -30,10 +61,25 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const dropAfter: {
     <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;

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,10 +7,25 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export const takeUntil = dual(2, (fx, predicate) => {
     return makeFx((sink) => combinators.withEarlyExit(sink, (sink) => fx.run(makeSink(sink.onFailure, (a) => {
@@ -24,10 +39,26 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export const takeUntilEffect = dual(2, (fx, predicate) => makeFx((sink) => combinators.withEarlyExit(sink, (sink) => fx.run(makeSink(sink.onFailure, (a) => Effect.matchCauseEffect(predicate(a), {
     onFailure: sink.onFailure,
@@ -37,9 +68,24 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export const dropAfter = dual(2, (fx, predicate) => makeFx((sink) => combinators.dropAfter(sink, predicate, (sink) => fx.run(sink))));

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

@@ -4,10 +4,25 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const takeWhile: {
     <A>(predicate: (a: A) => boolean): <E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
@@ -17,10 +32,26 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const takeWhileEffect: {
     <A, E2, R2>(predicate: (a: A) => Effect.Effect<boolean, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;

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,19 +5,50 @@ 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
- * @category combinators
+ * @category Selecting values
  */
 export const takeWhile = dual(2, (fx, predicate) => takeUntil(fx, (a) => !predicate(a)));
 /**
  * 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
- * @category combinators
+ * @category Selecting values
  */
 export const takeWhileEffect = dual(2, (fx, predicate) => takeUntilEffect(fx, (a) => Effect.map(predicate(a), (b) => !b)));

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

@@ -3,10 +3,26 @@ 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
- * @category combinators
+ * @category Transforming values
  */
 export declare const tap: {
     <A, E2 = never, R2 = never>(f: (a: A) => void | Effect.Effect<unknown, E2, R2>): <E, R>(self: Fx<A, E | E2, R>) => Fx<A, E | E2, R | R2>;

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,10 +5,26 @@ 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
- * @category combinators
+ * @category Transforming values
  */
 export const tap = dual(2, (self, f) => make((sink) => self.run(sinkCore.tapEffect(sink, (a) => {
     const x = f(a);

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

@@ -0,0 +1,79 @@
+import { Duration, Scope } from "effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Options for {@link throttle}. A duration-only call is leading-edge
+ * (`{ leading: true, trailing: false }`).
+ *
+ * @remarks
+ * ## Why
+ *
+ * Leading and trailing edges answer different interaction needs, so the
+ * window policy is explicit rather than hidden behind separate operators.
+ *
+ * ## Ownership and lifetime
+ *
+ * This immutable value owns no resource. `throttle` reads it when constructing
+ * the Fx; the resulting subscription owns the timer and pending value.
+ *
+ * @example
+ * ```ts
+ * import type { ThrottleOptions } from "@typed/fx/Fx"
+ *
+ * const options: ThrottleOptions = {
+ *   duration: "250 millis",
+ *   leading: true,
+ *   trailing: true
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ * @category Operator options
+ */
+export type ThrottleOptions = {
+    readonly duration: Duration.Input;
+    readonly leading?: boolean | undefined;
+    readonly trailing?: boolean | undefined;
+};
+/**
+ * Limits emissions to configured leading and trailing edges of fixed windows.
+ *
+ * Pass `{ duration, leading, trailing }` for trailing or both-edge behavior.
+ * A duration alone defaults to `{ leading: true, trailing: false }`.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Throttling bounds push frequency while allowing immediate feedback, a final
+ * settled value, or both, without moving timing state outside the Fx graph.
+ *
+ * ## Ownership and lifetime
+ *
+ * The first value opens a window. Leading mode emits it immediately. Values
+ * arriving while open replace one pending latest value; trailing mode emits
+ * that value when the timer closes, except that both-edge mode does not repeat
+ * the first value unless another arrived. Windows never overlap. Source errors
+ * propagate, source completion waits for the active window, and interruption
+ * stops the scoped timer and discards pending state.
+ *
+ * @example
+ * ```ts
+ * import { throttle } from "@typed/fx/Fx"
+ * import { fromIterable } from "@typed/fx/Fx"
+ *
+ * const bounded = throttle(fromIterable([1, 2, 3]), {
+ *   duration: "250 millis",
+ *   leading: true,
+ *   trailing: true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Time and rate
+ */
+export declare const throttle: {
+    (duration: Duration.Input): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>;
+    (options: ThrottleOptions): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R | Scope.Scope>;
+    <A, E, R>(fx: Fx<A, E, R>, duration: Duration.Input): Fx<A, E, R | Scope.Scope>;
+    <A, E, R>(fx: Fx<A, E, R>, options: ThrottleOptions): Fx<A, E, R | Scope.Scope>;
+};
+//# sourceMappingURL=throttle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/throttle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAC;AAOjD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAKnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CACzC,CAAC;AAsEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,QAAQ,EAAE;IACrB,CAAC,QAAQ,EAAE,QAAQ,CAAC,KAAK,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,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IACpF,CAAC,OAAO,EAAE,eAAe,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,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IACpF,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;IAChF,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,eAAe,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;CAoBjF,CAAC"}

package/dist/Fx/combinators/throttle.js

@@ -0,0 +1,99 @@
+import { Duration, Effect } from "effect";
+import * as FiberHandle from "effect/FiberHandle";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Ref from "effect/Ref";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { isFx } from "../TypeId.js";
+import { exhaustMap } from "./exhaustMap.js";
+import { extendScope } from "../internal/scope.js";
+const isOptions = (u) => typeof u === "object" && u !== null && "duration" in u && !Duration.isDuration(u);
+const resolve = (durationOrOptions) => {
+    if (isOptions(durationOrOptions)) {
+        return {
+            duration: durationOrOptions.duration,
+            leading: durationOrOptions.leading ?? true,
+            trailing: durationOrOptions.trailing ?? false,
+        };
+    }
+    return { duration: durationOrOptions, leading: true, trailing: false };
+};
+const throttleWindow = (fx, duration, leading, trailing) => make(Effect.fn(function* (sink) {
+    const open = yield* Ref.make(false);
+    const pending = yield* Ref.make(Option.none());
+    const extra = yield* Ref.make(false);
+    const window = yield* FiberHandle.make();
+    const closeWindow = Effect.gen(function* () {
+        const hadExtra = yield* Ref.get(extra);
+        const shouldEmit = trailing && (!leading || hadExtra) ? yield* Ref.get(pending) : Option.none();
+        yield* Ref.set(open, false);
+        yield* Ref.set(pending, Option.none());
+        yield* Ref.set(extra, false);
+        if (Option.isSome(shouldEmit)) {
+            yield* sink.onSuccess(shouldEmit.value);
+        }
+    });
+    yield* fx.run(makeSink(sink.onFailure, (a) => Effect.gen(function* () {
+        const isOpen = yield* Ref.get(open);
+        if (!isOpen) {
+            yield* Ref.set(open, true);
+            yield* Ref.set(pending, Option.some(a));
+            yield* Ref.set(extra, false);
+            if (leading) {
+                yield* sink.onSuccess(a);
+            }
+            yield* FiberHandle.run(window, Effect.sleep(duration).pipe(Effect.andThen(closeWindow)));
+            return;
+        }
+        yield* Ref.set(pending, Option.some(a));
+        yield* Ref.set(extra, true);
+    })));
+    yield* FiberHandle.awaitEmpty(window);
+}, extendScope));
+/**
+ * Limits emissions to configured leading and trailing edges of fixed windows.
+ *
+ * Pass `{ duration, leading, trailing }` for trailing or both-edge behavior.
+ * A duration alone defaults to `{ leading: true, trailing: false }`.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Throttling bounds push frequency while allowing immediate feedback, a final
+ * settled value, or both, without moving timing state outside the Fx graph.
+ *
+ * ## Ownership and lifetime
+ *
+ * The first value opens a window. Leading mode emits it immediately. Values
+ * arriving while open replace one pending latest value; trailing mode emits
+ * that value when the timer closes, except that both-edge mode does not repeat
+ * the first value unless another arrived. Windows never overlap. Source errors
+ * propagate, source completion waits for the active window, and interruption
+ * stops the scoped timer and discards pending state.
+ *
+ * @example
+ * ```ts
+ * import { throttle } from "@typed/fx/Fx"
+ * import { fromIterable } from "@typed/fx/Fx"
+ *
+ * const bounded = throttle(fromIterable([1, 2, 3]), {
+ *   duration: "250 millis",
+ *   leading: true,
+ *   trailing: true
+ * })
+ * ```
+ *
+ * @since 1.0.0
+ * @category Time and rate
+ */
+export const throttle = dual((args) => isFx(args[0]), (fx, durationOrOptions) => {
+    const { duration, leading, trailing } = resolve(durationOrOptions);
+    if (leading && !trailing) {
+        return exhaustMap(fx, (a) => make(Effect.fn(function* (sink) {
+            yield* sink.onSuccess(a);
+            yield* Effect.sleep(duration);
+        })));
+    }
+    return throttleWindow(fx, duration, leading, trailing);
+});