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

package/dist/Fx/combinators/repeat.js

@@ -0,0 +1,57 @@
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Ref from "effect/Ref";
+import * as Schedule from "effect/Schedule";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+/**
+ * Repeats the entire stream according to `schedule` after each successful
+ * completion. Failures are not repeated.
+ *
+ * `Schedule.recurs(n)` runs the stream `n + 1` times (the original plus `n`
+ * repeats), matching Effect `Stream.repeat`.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Repetition is a subscription-level decision: after one producer completes,
+ * a Schedule decides whether and when a fresh run should begin. Keeping that
+ * decision in Effect's Schedule preserves typed timing services and failures.
+ *
+ * ## Ownership and lifetime
+ *
+ * Runs are strictly sequential. Every source value is forwarded before the
+ * Schedule is stepped with `void`; a successful step sleeps as configured and
+ * starts a new source run. A source failure stops immediately and is never
+ * repeated. Schedule failure is forwarded; Schedule completion ends normally.
+ * Interruption cancels the active source or schedule sleep. No runs overlap.
+ *
+ * @example
+ * ```ts
+ * import { Schedule } from "effect"
+ * import { repeat } from "@typed/fx/Fx"
+ * import { succeed } from "@typed/fx/Fx"
+ *
+ * const threeTicks = repeat(succeed("tick"), Schedule.recurs(2))
+ * ```
+ *
+ * @since 1.0.0
+ * @category Time and rate
+ */
+export const repeat = dual(2, (self, schedule) => make((sink) => Effect.gen(function* () {
+    const step = yield* Schedule.toStepWithSleep(schedule);
+    const failed = yield* Ref.make(false);
+    const run = () => self
+        .run(makeSink((cause) => Ref.set(failed, true).pipe(Effect.andThen(sink.onFailure(cause))), sink.onSuccess))
+        .pipe(Effect.flatMap(() => Effect.flatMap(Ref.get(failed), (didFail) => {
+        if (didFail)
+            return Effect.void;
+        return Pull.matchEffect(step(undefined), {
+            onSuccess: run,
+            onFailure: sink.onFailure,
+            onDone: () => Effect.void,
+        });
+    })));
+    yield* run();
+})));

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

@@ -0,0 +1,45 @@
+import * as Cause from "effect/Cause";
+import * as Result from "effect/Result";
+import type { Fx } from "../Fx.js";
+/**
+ * Materializes success and failure of an Fx as `Result` values.
+ *
+ * - **Success**: each emitted value is wrapped as `Result.succeed(value)`.
+ * - **Failure**: any failure (including typed error, defect, and interrupt) is
+ *   materialized as `Result.fail(cause)`. The output error type is `Cause<E>`,
+ *   so defects and interrupts are explicitly represented in the `Result` and
+ *   the resulting Fx has error type `never`.
+ *
+ * The resulting Fx never fails at the stream level; all outcomes are emitted as
+ * `Result<A, Cause<E>>`. Consumers can use `Result.match` or `Result.isSuccess` /
+ * `Result.isFailure` to handle success vs failure (including defect/interrupt).
+ *
+ * @remarks
+ * ## Why
+ *
+ * `Result` is convenient when success and failure should travel through one
+ * data channel, while retaining the complete Cause rather than flattening it
+ * into the typed error alone.
+ *
+ * ## Ownership and lifetime
+ *
+ * Each source value emits one successful Result in order. A terminal cause
+ * emits one failed Result and ends normally. The source is subscribed once;
+ * no resource is acquired and an interrupt reported by the source becomes
+ * data, although interrupting the outer running fiber still stops the run.
+ *
+ * @example
+ * ```ts
+ * import { result } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const outcomes = result(fail("offline"))
+ * ```
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` emitting `Result<A, Cause<E>>`.
+ * @since 1.0.0
+ * @category Errors and recovery
+ */
+export declare const result: <A, E, R>(fx: Fx<A, E, R>) => Fx<Result.Result<A, Cause.Cause<E>>, never, R>;
+//# sourceMappingURL=result.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAExC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAM5F,CAAC"}

package/dist/Fx/combinators/result.js

@@ -0,0 +1,46 @@
+import * as Result from "effect/Result";
+import { make } from "../constructors/make.js";
+/**
+ * Materializes success and failure of an Fx as `Result` values.
+ *
+ * - **Success**: each emitted value is wrapped as `Result.succeed(value)`.
+ * - **Failure**: any failure (including typed error, defect, and interrupt) is
+ *   materialized as `Result.fail(cause)`. The output error type is `Cause<E>`,
+ *   so defects and interrupts are explicitly represented in the `Result` and
+ *   the resulting Fx has error type `never`.
+ *
+ * The resulting Fx never fails at the stream level; all outcomes are emitted as
+ * `Result<A, Cause<E>>`. Consumers can use `Result.match` or `Result.isSuccess` /
+ * `Result.isFailure` to handle success vs failure (including defect/interrupt).
+ *
+ * @remarks
+ * ## Why
+ *
+ * `Result` is convenient when success and failure should travel through one
+ * data channel, while retaining the complete Cause rather than flattening it
+ * into the typed error alone.
+ *
+ * ## Ownership and lifetime
+ *
+ * Each source value emits one successful Result in order. A terminal cause
+ * emits one failed Result and ends normally. The source is subscribed once;
+ * no resource is acquired and an interrupt reported by the source becomes
+ * data, although interrupting the outer running fiber still stops the run.
+ *
+ * @example
+ * ```ts
+ * import { result } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const outcomes = result(fail("offline"))
+ * ```
+ *
+ * @param fx - The `Fx` stream.
+ * @returns An `Fx` emitting `Result<A, Cause<E>>`.
+ * @since 1.0.0
+ * @category Errors and recovery
+ */
+export const result = (fx) => make((sink) => fx.run({
+    onSuccess: (value) => sink.onSuccess(Result.succeed(value)),
+    onFailure: (cause) => sink.onSuccess(Result.fail(cause)),
+}));

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

@@ -0,0 +1,53 @@
+import * as Schedule from "effect/Schedule";
+import type { Fx } from "../Fx.js";
+/**
+ * Retries the entire stream when its Cause contains a typed `Fail` accepted by
+ * `schedule`.
+ *
+ * The schedule is reset as soon as the first element of an attempt is emitted,
+ * matching Effect `Stream.retry`.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Retrying the whole producer, rather than a single value callback, gives a
+ * Schedule the typed failure that ended an attempt and lets it control backoff.
+ *
+ * ## Ownership and lifetime
+ *
+ * Attempts are sequential and reuse the same downstream sink. The first Fail
+ * found anywhere in the Cause is offered to the Schedule, so a composite Cause
+ * containing that Fail can be retried even when it also contains defects or
+ * interrupts; starting a new attempt discards the whole prior Cause. A Cause
+ * without a Fail terminates immediately. Schedule completion re-emits the last
+ * source Cause, while Schedule failure terminates with its own cause. Emitting
+ * any value resets the Schedule. External interruption cancels the active
+ * attempt or backoff sleep.
+ *
+ * @example
+ * ```ts
+ * import { Schedule } from "effect"
+ * import { retry } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const retried = retry(fail("offline"), Schedule.recurs(2))
+ * ```
+ *
+ * @example A composite Cause is retryable when it contains a Fail
+ * ```ts
+ * import { Cause, Schedule } from "effect"
+ * import { retry } from "@typed/fx/Fx"
+ * import { failCause } from "@typed/fx/Fx"
+ *
+ * const composite = Cause.combine(Cause.fail("offline"), Cause.die("decoder defect"))
+ * const retried = retry(failCause(composite), Schedule.recurs(2))
+ * ```
+ *
+ * @since 1.0.0
+ * @category Errors and recovery
+ */
+export declare const retry: {
+    <E, X, E2, R2>(schedule: Schedule.Schedule<X, E, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, X, E2, R2>(self: Fx<A, E, R>, schedule: Schedule.Schedule<X, E, E2, R2>): Fx<A, E | E2, R | R2>;
+};
+//# sourceMappingURL=retry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/retry.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAG5C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,KAAK,EAAE;IAClB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACxC,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IACtD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GACxC,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAwC1B,CAAC"}

package/dist/Fx/combinators/retry.js

@@ -0,0 +1,71 @@
+import * as Cause from "effect/Cause";
+import * as Effect from "effect/Effect";
+import { dual } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Ref from "effect/Ref";
+import * as Result from "effect/Result";
+import * as Schedule from "effect/Schedule";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+/**
+ * Retries the entire stream when its Cause contains a typed `Fail` accepted by
+ * `schedule`.
+ *
+ * The schedule is reset as soon as the first element of an attempt is emitted,
+ * matching Effect `Stream.retry`.
+ *
+ * @remarks
+ * ## Why
+ *
+ * Retrying the whole producer, rather than a single value callback, gives a
+ * Schedule the typed failure that ended an attempt and lets it control backoff.
+ *
+ * ## Ownership and lifetime
+ *
+ * Attempts are sequential and reuse the same downstream sink. The first Fail
+ * found anywhere in the Cause is offered to the Schedule, so a composite Cause
+ * containing that Fail can be retried even when it also contains defects or
+ * interrupts; starting a new attempt discards the whole prior Cause. A Cause
+ * without a Fail terminates immediately. Schedule completion re-emits the last
+ * source Cause, while Schedule failure terminates with its own cause. Emitting
+ * any value resets the Schedule. External interruption cancels the active
+ * attempt or backoff sleep.
+ *
+ * @example
+ * ```ts
+ * import { Schedule } from "effect"
+ * import { retry } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const retried = retry(fail("offline"), Schedule.recurs(2))
+ * ```
+ *
+ * @example A composite Cause is retryable when it contains a Fail
+ * ```ts
+ * import { Cause, Schedule } from "effect"
+ * import { retry } from "@typed/fx/Fx"
+ * import { failCause } from "@typed/fx/Fx"
+ *
+ * const composite = Cause.combine(Cause.fail("offline"), Cause.die("decoder defect"))
+ * const retried = retry(failCause(composite), Schedule.recurs(2))
+ * ```
+ *
+ * @since 1.0.0
+ * @category Errors and recovery
+ */
+export const retry = dual(2, (self, schedule) => make((sink) => Effect.gen(function* () {
+    const stepRef = yield* Ref.make(yield* Schedule.toStepWithSleep(schedule));
+    const reset = Effect.flatMap(Schedule.toStepWithSleep(schedule), (step) => Ref.set(stepRef, step));
+    const attempt = () => self.run(makeSink((cause) => {
+        const found = Cause.findFail(cause);
+        if (Result.isFailure(found)) {
+            return sink.onFailure(cause);
+        }
+        return Effect.flatMap(Ref.get(stepRef), (step) => Pull.matchEffect(step(found.success.error), {
+            onSuccess: () => attempt(),
+            onFailure: (stepCause) => sink.onFailure(stepCause),
+            onDone: () => sink.onFailure(cause),
+        }));
+    }, (a) => reset.pipe(Effect.andThen(sink.onSuccess(a)))));
+    yield* attempt();
+})));

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

@@ -0,0 +1,31 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Emits the latest source value whenever `sampler` emits. Source values that
+ * arrive between sampler ticks are not forwarded until the next tick.
+ *
+ * **Completion:** Completes when the source completes.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @remarks
+ * ## Why
+ * `sample` separates value production from observation cadence. A sampler tick emits the latest
+ * source value once, or nothing before the source's first value; repeated ticks may repeat a value.
+ *
+ * ## Ownership and lifetime
+ * One latest-value cell and a child sampler fiber belong to each run. Source completion interrupts
+ * the sampler; any failure or consumer interruption stops both and releases the retained value.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const snapshots = Fx.sample(Fx.fromIterable([10, 20]), Fx.fromIterable(["tick"]))
+ * ```
+ *
+ * @since 1.0.0
+ * @category Time and rate
+ */
+export declare const sample: {
+    <S, E2, R2>(sampler: Fx<S, E2, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, S, E2, R2>(self: Fx<A, E, R>, sampler: Fx<S, E2, R2>): Fx<A, E | E2, R | R2>;
+};
+//# sourceMappingURL=sample.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sample.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/sample.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAC3F,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAyBxF,CAAC"}

package/dist/Fx/combinators/sample.js

@@ -0,0 +1,42 @@
+import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
+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";
+/**
+ * Emits the latest source value whenever `sampler` emits. Source values that
+ * arrive between sampler ticks are not forwarded until the next tick.
+ *
+ * **Completion:** Completes when the source completes.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @remarks
+ * ## Why
+ * `sample` separates value production from observation cadence. A sampler tick emits the latest
+ * source value once, or nothing before the source's first value; repeated ticks may repeat a value.
+ *
+ * ## Ownership and lifetime
+ * One latest-value cell and a child sampler fiber belong to each run. Source completion interrupts
+ * the sampler; any failure or consumer interruption stops both and releases the retained value.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const snapshots = Fx.sample(Fx.fromIterable([10, 20]), Fx.fromIterable(["tick"]))
+ * ```
+ *
+ * @since 1.0.0
+ * @category Time and rate
+ */
+export const sample = dual(2, (self, sampler) => make(Effect.fn(function* (sink) {
+    const latest = yield* Ref.make(Option.none());
+    const samplerFiber = yield* Effect.forkChild(sampler.run(makeSink(sink.onFailure, () => Effect.flatMap(Ref.get(latest), (opt) => Option.match(opt, {
+        onNone: () => Effect.void,
+        onSome: (a) => sink.onSuccess(a),
+    })))));
+    yield* self
+        .run(makeSink(sink.onFailure, (a) => Ref.set(latest, Option.some(a))))
+        .pipe(Effect.ensuring(Fiber.interrupt(samplerFiber)));
+})));

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

@@ -0,0 +1,72 @@
+import * as Effect from "effect/Effect";
+import type { Fx } from "../Fx.js";
+/**
+ * Scans the stream with a pure function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` emits `f(state, a)` and updates state.
+ *
+ * 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.
+ * @since 1.0.0
+ * @category Stateful transforms
+ */
+export declare const scan: {
+    <S, A>(initial: S, f: (s: S, a: A) => S): <E, R>(fx: Fx<A, E, R>) => Fx<S, E, R>;
+    <A, E, R, S>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => S): Fx<S, E, R>;
+};
+/**
+ * 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.
+ * @since 1.0.0
+ * @category Stateful transforms
+ */
+export declare const scanEffect: {
+    <S, A, E2, R2>(initial: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): <E, R>(fx: Fx<A, E, R>) => Fx<S, E | E2, R | R2>;
+    <A, E, R, S, E2, R2>(fx: Fx<A, E, R>, initial: S, f: (s: S, a: A) => Effect.Effect<S, E2, R2>): Fx<S, E | E2, R | R2>;
+};
+//# sourceMappingURL=scan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/scan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,IAAI,EAAE;IACjB,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,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;IACjF,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC;CAa9E,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,UAAU,EAAE;IACvB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACX,OAAO,EAAE,CAAC,EACV,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAC1C,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,CAAC,EAAE,EAAE,EAAE,EAAE,EACjB,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACf,OAAO,EAAE,CAAC,EACV,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,GAC1C,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAwB1B,CAAC"}

package/dist/Fx/combinators/scan.js

@@ -0,0 +1,77 @@
+import * as Effect from "effect/Effect";
+import { dual, pipe } from "effect/Function";
+import { loop as sinkLoop, loopEffect as sinkLoopEffect } from "../../Sink/combinators.js";
+import { make } from "../constructors/make.js";
+/**
+ * Scans the stream with a pure function, emitting the accumulated state after each element.
+ * Emits the initial value first, then for each input `a` emits `f(state, a)` and updates state.
+ *
+ * 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.
+ * @since 1.0.0
+ * @category Stateful transforms
+ */
+export const scan = dual(3, (fx, initial, f) => make((sink) => Effect.gen(function* () {
+    yield* sink.onSuccess(initial);
+    yield* fx.run(sinkLoop(sink, initial, (s, a) => {
+        const next = f(s, a);
+        return [next, next];
+    }));
+})));
+/**
+ * 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.
+ * @since 1.0.0
+ * @category Stateful transforms
+ */
+export const scanEffect = dual(3, (fx, initial, f) => make((sink) => Effect.gen(function* () {
+    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.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 Time and rate
+ */
+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 Time and rate
+ */
+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

@@ -1,14 +1,58 @@
+import * as Effect from "effect/Effect";
 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
- * @category combinators
+ * @category Selecting values
  */
 export declare const skip: {
     (n: number): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E, R>;
     <A, E, R>(fx: Fx<A, E, R>, n: number): Fx<A, E, R>;
 };
+/**
+ * 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
+ * @category Selecting values
+ */
+export declare const skipEffect: {
+    <E2, R2>(count: Effect.Effect<number, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A, E | E2, R | R2>;
+    <A, E, R, E2, R2>(fx: Fx<A, E, R>, count: Effect.Effect<number, E2, R2>): Fx<A, E | E2, R | R2>;
+};
 //# sourceMappingURL=skip.d.ts.map

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":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;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"}
+{"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"}