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

package/dist/Fx/combinators/scan.js

@@ -8,6 +8,22 @@ import { make } from "../constructors/make.js";
  *
  * Semantics align with Effect Stream's `scan`: output is `initial`, `f(initial, a1)`, `f(..., a2)`, ...
  *
+ * @remarks
+ * ## Why
+ * `scan` exposes every accumulated state, including `initial` before the source is run. For `n`
+ * inputs it emits `n + 1` states in order, making incremental reduction observable.
+ *
+ * ## Ownership and lifetime
+ * Each run owns an independent accumulator and releases it when the run ends. The pure reducer
+ * acquires no resources and preserves source failures, services, and interruption.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const totals = Fx.fromIterable([1, 2, 3]).pipe(Fx.scan(0, (sum, n) => sum + n))
+ * ```
+ *
  * @param initial - Initial state (first value emitted).
  * @param f - Reducer `(state, value) => nextState`.
  * @returns An `Fx` that emits the accumulated state at each step.
@@ -25,6 +41,29 @@ export const scan = dual(3, (fx, initial, f) => make((sink) => Effect.gen(functi
  * Scans the stream with an effectful function, emitting the accumulated state after each element.
  * Emits the initial value first, then for each input `a` runs `f(state, a)` and emits the resulting state.
  *
+ * @remarks
+ * ## Why
+ * `scanEffect` permits a failing or service-backed accumulated transition and emits `initial`
+ * before subscribing. It does not serialize later producer callbacks: overlapping reductions can
+ * read the same state, finish out of order, and overwrite one another's next state.
+ *
+ * ## Ownership and lifetime
+ * One mutable accumulator is owned per run. Reducer Effects inherit producer concurrency and use
+ * the captured services. Failure is delivered to the Sink without committing that transition;
+ * interruption follows the invoking callback rather than locking the entire run.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ *
+ * const concurrent = Fx.make<number>((sink) =>
+ *   Effect.all([sink.onSuccess(1), sink.onSuccess(2)], { concurrency: "unbounded", discard: true })
+ * )
+ * const program = Fx.collectAll(concurrent.pipe(Fx.scanEffect(0, (sum, n) => Effect.succeed(sum + n))))
+ * // Both overlapping reductions may observe sum === 0; serialize the producer for atomic totals.
+ * ```
+ *
  * @param initial - Initial state (first value emitted).
  * @param f - Effectful reducer `(state, value) => Effect<nextState>`.
  * @returns An `Fx` that emits the accumulated state at each step.
@@ -32,7 +71,7 @@ export const scan = dual(3, (fx, initial, f) => make((sink) => Effect.gen(functi
  * @category combinators
  */
 export const scanEffect = dual(3, (fx, initial, f) => make((sink) => Effect.gen(function* () {
-    const services = yield* Effect.services();
+    const services = yield* Effect.context();
     yield* sink.onSuccess(initial);
-    yield* fx.run(sinkLoopEffect(sink, initial, (s, a) => pipe(f(s, a), Effect.catchCause((cause) => sink.onFailure(cause).pipe(Effect.as(s))), Effect.map((next) => [next, next]), Effect.provideServices(services))));
+    yield* fx.run(sinkLoopEffect(sink, initial, (s, a) => pipe(f(s, a), Effect.catchCause((cause) => sink.onFailure(cause).pipe(Effect.as(s))), Effect.map((next) => [next, next]), Effect.provideContext(services))));
 })));

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

@@ -0,0 +1,30 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Drops `events` until `signal` emits, then forwards the rest.
+ *
+ * @remarks
+ * ## Why
+ * `since` uses one Fx as a start boundary for another. Events before the first signal are dropped;
+ * after it arrives, remaining events emit in their original order. Signal values are not emitted.
+ *
+ * ## Ownership and lifetime
+ * Event and signal runs share a child Scope. The signal observer fiber is forked but never joined:
+ * a signal failure ends that fiber and is discarded rather than delivered to the event Sink, so it
+ * does not stop events. Event completion closes the Scope; consumer interruption stops both runs.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * // This Effect succeeds with []; the failed signal neither opens the gate nor fails collection.
+ * const program = Fx.collectAll(Fx.since(Fx.fromIterable([1, 2]), Fx.fail("signal failed")))
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export declare const since: {
+    <B, E2, R2>(signal: Fx<B, E2, R2>): <A, E, R>(events: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, B, E2, R2>(events: Fx<A, E, R>, signal: Fx<B, E2, R2>): Fx<A, E | E2, R | R2>;
+};
+//# sourceMappingURL=since.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"since.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/since.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAInC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAC5F,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAsBzF,CAAC"}

package/dist/Fx/combinators/since.js

@@ -0,0 +1,39 @@
+import { Effect, Fiber, Scope } from "effect";
+import { dual } from "effect/Function";
+import { make } from "../constructors/make.js";
+import { observe } from "../run/observe.js";
+import { filter } from "./filter.js";
+/**
+ * Drops `events` until `signal` emits, then forwards the rest.
+ *
+ * @remarks
+ * ## Why
+ * `since` uses one Fx as a start boundary for another. Events before the first signal are dropped;
+ * after it arrives, remaining events emit in their original order. Signal values are not emitted.
+ *
+ * ## Ownership and lifetime
+ * Event and signal runs share a child Scope. The signal observer fiber is forked but never joined:
+ * a signal failure ends that fiber and is discarded rather than delivered to the event Sink, so it
+ * does not stop events. Event completion closes the Scope; consumer interruption stops both runs.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * // This Effect succeeds with []; the failed signal neither opens the gate nor fails collection.
+ * const program = Fx.collectAll(Fx.since(Fx.fromIterable([1, 2]), Fx.fail("signal failed")))
+ * ```
+ *
+ * @since 1.0.0
+ * @category combinators
+ */
+export const since = dual(2, (events, signal) => make(Effect.fn(function* (sink) {
+    let ready = false;
+    const scope = yield* Scope.make();
+    const eventsFiber = yield* Effect.forkIn(events.pipe(filter(() => ready)).run(sink), scope);
+    yield* signal.pipe(observe(() => {
+        ready = true;
+        return Effect.interrupt;
+    }), Effect.forkIn(scope));
+    yield* Fiber.join(eventsFiber).pipe(Effect.onExit((exit) => Scope.close(scope, exit)));
+})));

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

@@ -3,6 +3,21 @@ import type { Fx } from "../Fx.js";
 /**
  * Skips the first `n` elements of an Fx.
  *
+ * @remarks
+ * ## Why
+ * `skip` discards only the first `n` pushes, then forwards every later value in source order.
+ *
+ * ## Ownership and lifetime
+ * A counter is local to each run and no resource is acquired. Completion, failure, services, and
+ * interruption otherwise follow the source.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const tail = Fx.fromIterable([1, 2, 3]).pipe(Fx.skip(1))
+ * ```
+ *
  * @param n - The number of elements to skip.
  * @returns An `Fx` that emits values after the first `n` elements.
  * @since 1.0.0
@@ -15,6 +30,22 @@ export declare const skip: {
 /**
  * Skips the first `n` elements where `n` is produced by an Effect.
  *
+ * @remarks
+ * ## Why
+ * `skipEffect` obtains the prefix length at consumption time before subscribing to the source.
+ *
+ * ## Ownership and lifetime
+ * The count Effect runs once per run and can fail, require services, or be interrupted. The source
+ * is acquired only after the count succeeds.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ *
+ * const tail = Fx.fromIterable([1, 2]).pipe(Fx.skipEffect(Effect.succeed(1)))
+ * ```
+ *
  * @param count - Effect that produces the number of elements to skip.
  * @returns An `Fx` that emits values after the first `n` elements.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"skip.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skip.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;CAIpD,CAAC;AAEF;;;;;;;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":"skip.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAInC;;;;;;;;;;;;;;;;;;;;;;GAsBG;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;CAGpD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;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/skip.js

@@ -5,6 +5,21 @@ import { unwrap } from "./unwrap.js";
 /**
  * Skips the first `n` elements of an Fx.
  *
+ * @remarks
+ * ## Why
+ * `skip` discards only the first `n` pushes, then forwards every later value in source order.
+ *
+ * ## Ownership and lifetime
+ * A counter is local to each run and no resource is acquired. Completion, failure, services, and
+ * interruption otherwise follow the source.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const tail = Fx.fromIterable([1, 2, 3]).pipe(Fx.skip(1))
+ * ```
+ *
  * @param n - The number of elements to skip.
  * @returns An `Fx` that emits values after the first `n` elements.
  * @since 1.0.0
@@ -14,6 +29,22 @@ export const skip = dual(2, (fx, n) => slice(fx, { skip: n, take: Infinity }));
 /**
  * Skips the first `n` elements where `n` is produced by an Effect.
  *
+ * @remarks
+ * ## Why
+ * `skipEffect` obtains the prefix length at consumption time before subscribing to the source.
+ *
+ * ## Ownership and lifetime
+ * The count Effect runs once per run and can fail, require services, or be interrupted. The source
+ * is acquired only after the count succeeds.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ *
+ * const tail = Fx.fromIterable([1, 2]).pipe(Fx.skipEffect(Effect.succeed(1)))
+ * ```
+ *
  * @param count - Effect that produces the number of elements to skip.
  * @returns An `Fx` that emits values after the first `n` elements.
  * @since 1.0.0

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

@@ -2,6 +2,22 @@ import type { Fx } from "../Fx.js";
 /**
  * Drops elements that are equal to the previous element using standard equality.
  *
+ * @remarks
+ * ## Why
+ * `skipRepeats` removes only consecutive duplicates using Effect's structural equality. The first
+ * value always emits; distinct values remain ordered, and a value may emit again after a change.
+ *
+ * ## Ownership and lifetime
+ * One previous value is retained for each run and released when it ends. The operation owns no
+ * external resource and preserves source errors, services, and interruption.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const distinctRuns = Fx.fromIterable([1, 1, 2, 1]).pipe(Fx.skipRepeats)
+ * ```
+ *
  * @param fx - The `Fx` stream.
  * @returns An `Fx` with consecutive duplicates removed.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"skipRepeats.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipRepeats.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAKnC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE,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,CAAgB,CAAC"}
+{"version":3,"file":"skipRepeats.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipRepeats.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAKnC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,WAAW,EAAE,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,CAAgB,CAAC"}

package/dist/Fx/combinators/skipRepeats.js

@@ -4,6 +4,22 @@ const skipRepeats_ = skipRepeatsWith(equals);
 /**
  * Drops elements that are equal to the previous element using standard equality.
  *
+ * @remarks
+ * ## Why
+ * `skipRepeats` removes only consecutive duplicates using Effect's structural equality. The first
+ * value always emits; distinct values remain ordered, and a value may emit again after a change.
+ *
+ * ## Ownership and lifetime
+ * One previous value is retained for each run and released when it ends. The operation owns no
+ * external resource and preserves source errors, services, and interruption.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const distinctRuns = Fx.fromIterable([1, 1, 2, 1]).pipe(Fx.skipRepeats)
+ * ```
+ *
  * @param fx - The `Fx` stream.
  * @returns An `Fx` with consecutive duplicates removed.
  * @since 1.0.0

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

@@ -3,6 +3,23 @@ import type { Fx } from "../Fx.js";
 /**
  * Drops elements that are equal to the previous element using a custom equivalence function.
  *
+ * @remarks
+ * ## Why
+ * `skipRepeatsWith` defines consecutive equality for values that need domain-specific comparison.
+ * It compares against the last emitted value, emits the first value, and otherwise preserves order.
+ *
+ * ## Ownership and lifetime
+ * The per-run previous-value state is updated atomically and released when observation ends. The
+ * pure equivalence adds no failures or services and acquires no resource.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const byId = Fx.skipRepeatsWith<{ id: number }>((a, b) => a.id === b.id)
+ * const changes = Fx.fromIterable([{ id: 1 }, { id: 1 }, { id: 2 }]).pipe(byId)
+ * ```
+ *
  * @param Eq - The equivalence function to use.
  * @returns An `Fx` with consecutive duplicates removed.
  * @since 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"skipRepeatsWith.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipRepeatsWith.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAMvD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GACzB,CAAC,EAAE,IAAI,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,MACjC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAoBhC,CAAC"}
+{"version":3,"file":"skipRepeatsWith.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipRepeatsWith.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,WAAW,MAAM,oBAAoB,CAAC;AAMvD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,eAAe,GACzB,CAAC,MAAM,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,MACjC,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAoBhC,CAAC"}

package/dist/Fx/combinators/skipRepeatsWith.js

@@ -7,6 +7,23 @@ import { make } from "../constructors/make.js";
 /**
  * Drops elements that are equal to the previous element using a custom equivalence function.
  *
+ * @remarks
+ * ## Why
+ * `skipRepeatsWith` defines consecutive equality for values that need domain-specific comparison.
+ * It compares against the last emitted value, emits the first value, and otherwise preserves order.
+ *
+ * ## Ownership and lifetime
+ * The per-run previous-value state is updated atomically and released when observation ends. The
+ * pure equivalence adds no failures or services and acquires no resource.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const byId = Fx.skipRepeatsWith<{ id: number }>((a, b) => a.id === b.id)
+ * const changes = Fx.fromIterable([{ id: 1 }, { id: 1 }, { id: 2 }]).pipe(byId)
+ * ```
+ *
  * @param Eq - The equivalence function to use.
  * @returns An `Fx` with consecutive duplicates removed.
  * @since 1.0.0

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

@@ -4,6 +4,21 @@ import type { Fx } from "../Fx.js";
  * Skips elements from an Fx while a predicate returns true.
  * Emits from the first element for which the predicate returns false (including that element) and all following elements.
  *
+ * @remarks
+ * ## Why
+ * `skipWhile` discards only the longest matching prefix. The first false value opens the gate and is
+ * emitted; later values are forwarded without re-running the predicate.
+ *
+ * ## Ownership and lifetime
+ * One boolean gate is owned by each run and then discarded. No resource is acquired and source
+ * errors, services, and interruption are preserved.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([1, 2, 1]).pipe(Fx.skipWhile((n) => n < 2))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that emits once the predicate first fails.
  * @since 1.0.0
@@ -17,6 +32,32 @@ export declare const skipWhile: {
  * Skips elements from an Fx while an effectful predicate returns true.
  * Emits from the first element for which the predicate effect succeeds with false (including that element) and all following elements.
  *
+ * @remarks
+ * ## Why
+ * `skipWhileEffect` performs Effectful prefix decisions. The gate opens at the first false result,
+ * but the implementation eagerly constructs and runs `predicate(a)` before reading that gate, so
+ * the predicate still runs for every later input even though those values are always forwarded.
+ *
+ * ## Ownership and lifetime
+ * The gate belongs to one run, while predicate invocation inherits the producer's ordering and
+ * concurrency. Predicate failure is delivered even after the gate opened; services remain required
+ * and interruption cancels whichever callback Effects the producer attached to the run.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Ref } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const program = Effect.gen(function* () {
+ *   const checks = yield* Ref.make(0)
+ *   const values = yield* Fx.collectAll(
+ *     Fx.fromIterable([2, 3]).pipe(
+ *       Fx.skipWhileEffect((n) => Ref.update(checks, (count) => count + 1).pipe(Effect.as(n < 2)))
+ *     )
+ *   )
+ *   return { values, checks: yield* Ref.get(checks) } // { values: [2, 3], checks: 2 }
+ * })
+ * ```
+ *
  * @param predicate - Effectful predicate function.
  * @returns An `Fx` that emits once the predicate first fails.
  * @since 1.0.0
@@ -29,6 +70,19 @@ export declare const skipWhileEffect: {
 /**
  * Alias of `skipWhile` for Effect parity (`dropWhile` naming).
  *
+ * @remarks
+ * ## Why
+ * `dropWhile` provides Effect Stream naming for the same prefix-dropping behavior as `skipWhile`.
+ *
+ * ## Ownership and lifetime
+ * This alias has exactly `skipWhile`'s per-run gate and acquires no additional resource.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([0, 1]).pipe(Fx.dropWhile((n) => n === 0))
+ * ```
+ *
  * @since 1.0.0
  * @category combinators
  */
@@ -39,6 +93,20 @@ export declare const dropWhile: {
 /**
  * Alias of `skipWhileEffect` for Effect parity (`dropWhileEffect` naming).
  *
+ * @remarks
+ * ## Why
+ * `dropWhileEffect` provides Effect Stream naming for Effectful prefix dropping.
+ *
+ * ## Ownership and lifetime
+ * This alias retains `skipWhileEffect`'s failure, service, state, and interruption semantics.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([0, 1]).pipe(Fx.dropWhileEffect((n) => Effect.succeed(n === 0)))
+ * ```
+ *
  * @since 1.0.0
  * @category combinators
  */

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

@@ -1 +1 @@
-{"version":3,"file":"skipWhile.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipWhile.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"skipWhile.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/skipWhile.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,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;CAkBvE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;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;CA2B1B,CAAC;AAEF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,SAAS;KA/GnB,CAAC,aAAa,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;KACxE,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;CA8GrC,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,eAAe;KA5EzB,CAAC,EAAE,EAAE,EAAE,EAAE,aACG,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;KAClD,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,MACV,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,aACJ,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;CAsEoB,CAAC"}

package/dist/Fx/combinators/skipWhile.js

@@ -7,6 +7,21 @@ import { make as makeSink } from "../../Sink/Sink.js";
  * Skips elements from an Fx while a predicate returns true.
  * Emits from the first element for which the predicate returns false (including that element) and all following elements.
  *
+ * @remarks
+ * ## Why
+ * `skipWhile` discards only the longest matching prefix. The first false value opens the gate and is
+ * emitted; later values are forwarded without re-running the predicate.
+ *
+ * ## Ownership and lifetime
+ * One boolean gate is owned by each run and then discarded. No resource is acquired and source
+ * errors, services, and interruption are preserved.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([1, 2, 1]).pipe(Fx.skipWhile((n) => n < 2))
+ * ```
+ *
  * @param predicate - The predicate function.
  * @returns An `Fx` that emits once the predicate first fails.
  * @since 1.0.0
@@ -29,6 +44,32 @@ export const skipWhile = dual(2, (fx, predicate) => makeFx((sink) => Effect.gen(
  * Skips elements from an Fx while an effectful predicate returns true.
  * Emits from the first element for which the predicate effect succeeds with false (including that element) and all following elements.
  *
+ * @remarks
+ * ## Why
+ * `skipWhileEffect` performs Effectful prefix decisions. The gate opens at the first false result,
+ * but the implementation eagerly constructs and runs `predicate(a)` before reading that gate, so
+ * the predicate still runs for every later input even though those values are always forwarded.
+ *
+ * ## Ownership and lifetime
+ * The gate belongs to one run, while predicate invocation inherits the producer's ordering and
+ * concurrency. Predicate failure is delivered even after the gate opened; services remain required
+ * and interruption cancels whichever callback Effects the producer attached to the run.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Ref } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const program = Effect.gen(function* () {
+ *   const checks = yield* Ref.make(0)
+ *   const values = yield* Fx.collectAll(
+ *     Fx.fromIterable([2, 3]).pipe(
+ *       Fx.skipWhileEffect((n) => Ref.update(checks, (count) => count + 1).pipe(Effect.as(n < 2)))
+ *     )
+ *   )
+ *   return { values, checks: yield* Ref.get(checks) } // { values: [2, 3], checks: 2 }
+ * })
+ * ```
+ *
  * @param predicate - Effectful predicate function.
  * @returns An `Fx` that emits once the predicate first fails.
  * @since 1.0.0
@@ -53,6 +94,19 @@ export const skipWhileEffect = dual(2, (fx, predicate) => makeFx((sink) => Effec
 /**
  * Alias of `skipWhile` for Effect parity (`dropWhile` naming).
  *
+ * @remarks
+ * ## Why
+ * `dropWhile` provides Effect Stream naming for the same prefix-dropping behavior as `skipWhile`.
+ *
+ * ## Ownership and lifetime
+ * This alias has exactly `skipWhile`'s per-run gate and acquires no additional resource.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([0, 1]).pipe(Fx.dropWhile((n) => n === 0))
+ * ```
+ *
  * @since 1.0.0
  * @category combinators
  */
@@ -60,6 +114,20 @@ export const dropWhile = skipWhile;
 /**
  * Alias of `skipWhileEffect` for Effect parity (`dropWhileEffect` naming).
  *
+ * @remarks
+ * ## Why
+ * `dropWhileEffect` provides Effect Stream naming for Effectful prefix dropping.
+ *
+ * ## Ownership and lifetime
+ * This alias retains `skipWhileEffect`'s failure, service, state, and interruption semantics.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { Fx } from "@typed/fx"
+ * const values = Fx.fromIterable([0, 1]).pipe(Fx.dropWhileEffect((n) => Effect.succeed(n === 0)))
+ * ```
+ *
  * @since 1.0.0
  * @category combinators
  */

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

@@ -2,16 +2,81 @@ import * as Effect from "effect/Effect";
 import type { Fx } from "../Fx.js";
 /**
  * Defines the bounds for slicing an Fx stream.
+ *
+ * @remarks
+ * ## Why
+ * `Bounds` keeps the two independent slice decisions explicit: `skip` counts discarded prefix
+ * values and `take` bounds the following output.
+ *
+ * ## Ownership and lifetime
+ * This immutable model acquires no resources. A consumer decides how to normalize unusual numeric
+ * values when applying it.
+ *
+ * @example
+ * ```ts
+ * import type { Fx } from "@typed/fx"
+ *
+ * const page: Fx.Bounds = { skip: 20, take: 10 }
+ * ```
  * @since 1.0.0
  * @category models
  */
 export interface Bounds {
+    /**
+     * Number of source values discarded before the slice can emit.
+     *
+     * @remarks
+     * ## Why
+     * Keeping the prefix count separate from `take` permits windows that begin anywhere in a source.
+     *
+     * ## Ownership and lifetime
+     * This number stores no state and acquires no resources; `slice` copies it into a per-run counter.
+     *
+     * @example
+     * ```ts
+     * import type { Fx } from "@typed/fx"
+     * const bounds: Fx.Bounds = { skip: 2, take: 1 }
+     * ```
+     */
     readonly skip: number;
+    /**
+     * Maximum number of values emitted after the skipped prefix.
+     *
+     * @remarks
+     * ## Why
+     * The output bound makes early completion explicit without buffering the selected values.
+     *
+     * ## Ownership and lifetime
+     * This number stores no state and acquires no resources; `slice` owns the corresponding counter
+     * only for the duration of one run.
+     *
+     * @example
+     * ```ts
+     * import type { Fx } from "@typed/fx"
+     * const bounds: Fx.Bounds = { skip: 0, take: 10 }
+     * ```
+     */
     readonly take: number;
 }
 /**
  * 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
@@ -24,6 +89,23 @@ export declare const slice: {
 /**
  * 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/slice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slice.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/slice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;GAIG;AACH,MAAM,WAAW,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB,CAAC,MAAM,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;IAE5D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAKzD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,CAAC,EAAE,EAAE,EAAE,EACL,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GACpC,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,MAAM,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;CAOlG,CAAC"}
+{"version":3,"file":"slice.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/slice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,MAAM;IACrB;;;;;;;;;;;;;;;OAeG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;;;;;;;;;;;;OAgBG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB,CAAC,MAAM,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;IAE5D,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAGzD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,CAAC,EAAE,EAAE,EAAE,EACL,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC,GACpC,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,MAAM,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;CAOlG,CAAC"}