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

package/dist/Fx/combinators/mergeOrdered.js

@@ -2,36 +2,75 @@ import * as Cause from "effect/Cause";
 import * as Deferred from "effect/Deferred";
 import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
 import * as Sink from "../../Sink/Sink.js";
 import { make } from "../constructors/make.js";
 /**
- * Merges multiple Fx streams concurrently but emits values in the order of the input streams.
+ * Runs multiple Fx streams concurrently while draining their values in argument order.
  *
- * This ensures that values from the first Fx are emitted before values from the second Fx, and so on.
- * Values from later streams are buffered until earlier streams complete or emit their values (depending on semantics, but usually this means strictly ordered emission).
+ * @remarks
+ * ## Why
+ *
+ * `mergeOrdered` overlaps production latency while preserving the same output
+ * grouping as sequential concatenation. It is useful only when that ordering is
+ * worth retaining later results in memory.
+ *
+ * ## Concurrency, ordering, and buffering
+ *
+ * Every input starts immediately. Input zero forwards as it produces. Values
+ * from each later input are buffered until every earlier input ends, then drained
+ * in that input's emission order before the next buffer is released. Buffering
+ * is unbounded: a fast or infinite later input can retain arbitrary values while
+ * an earlier input remains open.
+ *
+ * ## Ownership and lifetime
+ *
+ * Non-interruption failures are forwarded. Interrupt-only causes mark that input
+ * ended so they cannot deadlock later buffers. All input services remain typed.
+ * The observing fiber owns all runs and buffers; completion waits for all inputs,
+ * while interruption discards buffers and interrupts remaining resource scopes.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * import { Effect } from "effect"
+ *
+ * const ordered = Fx.mergeOrdered(
+ *   Fx.at("slow first", "20 millis"),
+ *   Fx.at("fast second", "1 millis")
+ * )
+ * Effect.runPromise(Fx.collectAll(ordered)).then(console.log)
+ * // ["slow first", "fast second"]: the second value waits in its buffer
+ * ```
  *
  * @param fx - The Fx streams to merge.
  * @returns An `Fx` that emits values in order.
  * @since 1.0.0
- * @category combinators
+ * @category Combining sources
  */
 export function mergeOrdered(...fx) {
     return make(Effect.fn(function* (sink) {
-        const { makeSink, onEnd } = withBuffers(fx.length, sink);
-        yield* Effect.forEach(fx, (fx, i) => Effect.onExit(fx.run(makeSink(i)), () => onEnd(i)), {
+        const { makeSink, onEnd, discard } = withBuffers(fx.length, sink);
+        const run = Effect.forEach(fx, (fx, i) => Effect.onExit(fx.run(makeSink(i)), () => onEnd(i)), {
             concurrency: "unbounded",
             discard: true,
         });
+        yield* Effect.acquireUseRelease(run.pipe(Effect.forkChild({ startImmediately: true })), Fiber.join, (fiber) => discard.pipe(Effect.andThen(Fiber.interrupt(fiber))));
     }));
 }
 function withBuffers(size, sink) {
     const buffers = indexedBuffers(size, sink);
     const onSuccess = (index, value) => buffers.get(index).onSuccess(value);
     const onEnd = (index) => buffers.get(index).onEnd;
+    const discard = Effect.sync(() => {
+        for (const buffer of buffers.values())
+            buffer.discard();
+    });
     const makeSink = (index) => Sink.make((cause) => (Cause.hasInterruptsOnly(cause) ? onEnd(index) : sink.onFailure(cause)), (value) => onSuccess(index, value));
     return {
         onSuccess,
         onEnd,
+        discard,
         makeSink,
     };
 }
@@ -60,12 +99,16 @@ function indexedBuffers(size, sink) {
 }
 function IndexedBuffer(state, sink, onDone) {
     let buffer = [];
+    let active = true;
+    const forward = (value) => Effect.suspend(() => (active ? sink.onSuccess(value) : Effect.void));
     const onSuccess = (value) => {
+        if (!active)
+            return Effect.void;
         if (state.ready) {
             if (buffer.length === 0)
-                return sink.onSuccess(value);
+                return forward(value);
             buffer.push(value);
-            const effect = Effect.forEach(buffer, sink.onSuccess);
+            const effect = Effect.forEach(buffer, forward);
             buffer = [];
             return effect;
         }
@@ -74,16 +117,27 @@ function IndexedBuffer(state, sink, onDone) {
             return Effect.void;
         }
     };
-    const onEnd = Effect.flatMap(Deferred.await(state.deferred), () => {
-        if (buffer.length === 0)
-            return onDone;
-        const effect = Effect.forEach(buffer, sink.onSuccess);
-        buffer = [];
-        return Effect.ensuring(effect, onDone);
+    const onEnd = Effect.suspend(() => {
+        if (!active)
+            return Effect.void;
+        return Effect.flatMap(Deferred.await(state.deferred), () => {
+            if (!active)
+                return Effect.void;
+            if (buffer.length === 0)
+                return onDone;
+            const effect = Effect.forEach(buffer, forward);
+            buffer = [];
+            return Effect.ensuring(effect, onDone);
+        });
     });
     return {
         state,
         onSuccess,
         onEnd,
+        discard: () => {
+            active = false;
+            buffer = [];
+            Deferred.doneUnsafe(state.deferred, Exit.void);
+        },
     };
 }

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

@@ -2,13 +2,43 @@ import type * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import type { Fx } from "../Fx.js";
 /**
- * Adds an `Effect.onError`-style finalizer to an `Fx`.
+ * Runs cleanup after the source reports a failure cause.
  *
- * The cleanup is run only if the stream fails (including defects / interrupts
- * carried in the `Cause`).
+ * @remarks
+ * ## Why
+ *
+ * Failure-only observation belongs at the stream boundary when cleanup needs
+ * the complete Cause rather than merely the typed error.
+ *
+ * ## Ownership and lifetime
+ *
+ * The original cause is delivered downstream first. Cleanup runs only if that
+ * downstream `onFailure` Effect succeeds; if the sink itself fails or interrupts,
+ * `flatMap` never reaches cleanup. Typed cleanup failure is impossible by
+ * signature, but `Effect.ignore` does not suppress defects or interruption:
+ * either can fail or interrupt the run after the source Cause was handled. Its
+ * services are required for the subscription, and it does not run after success.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { onError } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const logged = onError(fail("offline"), (cause) => Effect.logError(cause))
+ * ```
+ *
+ * @example A cleanup defect is not a typed failure
+ * ```ts
+ * import { Effect } from "effect"
+ * import { onError } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const defectiveCleanup = onError(fail("offline"), () => Effect.die("logger defect"))
+ * ```
  *
  * @since 1.0.0
- * @category combinators
+ * @category Observing failures
  */
 export declare const onError: {
     <E, X, R2>(cleanup: (cause: Cause.Cause<E>) => Effect.Effect<X, never, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;

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

@@ -1 +1 @@
-{"version":3,"file":"onError.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;GAQG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EACP,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAC9D,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAEjD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAC9D,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAerB,CAAC"}
+{"version":3,"file":"onError.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onError.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAIxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,eAAO,MAAM,OAAO,EAAE;IACpB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,EACP,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAC9D,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;IAEjD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EACb,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,OAAO,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC,GAC9D,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAerB,CAAC"}

package/dist/Fx/combinators/onError.js

@@ -3,12 +3,42 @@ import { dual } from "effect/Function";
 import { make as makeSink } from "../../Sink/Sink.js";
 import { make } from "../constructors/make.js";
 /**
- * Adds an `Effect.onError`-style finalizer to an `Fx`.
+ * Runs cleanup after the source reports a failure cause.
  *
- * The cleanup is run only if the stream fails (including defects / interrupts
- * carried in the `Cause`).
+ * @remarks
+ * ## Why
+ *
+ * Failure-only observation belongs at the stream boundary when cleanup needs
+ * the complete Cause rather than merely the typed error.
+ *
+ * ## Ownership and lifetime
+ *
+ * The original cause is delivered downstream first. Cleanup runs only if that
+ * downstream `onFailure` Effect succeeds; if the sink itself fails or interrupts,
+ * `flatMap` never reaches cleanup. Typed cleanup failure is impossible by
+ * signature, but `Effect.ignore` does not suppress defects or interruption:
+ * either can fail or interrupt the run after the source Cause was handled. Its
+ * services are required for the subscription, and it does not run after success.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { onError } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const logged = onError(fail("offline"), (cause) => Effect.logError(cause))
+ * ```
+ *
+ * @example A cleanup defect is not a typed failure
+ * ```ts
+ * import { Effect } from "effect"
+ * import { onError } from "@typed/fx/Fx"
+ * import { fail } from "@typed/fx/Fx"
+ *
+ * const defectiveCleanup = onError(fail("offline"), () => Effect.die("logger defect"))
+ * ```
  *
  * @since 1.0.0
- * @category combinators
+ * @category Observing failures
  */
 export const onError = dual(2, (self, cleanup) => make((sink) => self.run(makeSink((cause) => Effect.flatMap(sink.onFailure(cause), () => Effect.ignore(cleanup(cause))), sink.onSuccess))));

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

@@ -2,12 +2,38 @@ import * as Effect from "effect/Effect";
 import * as Exit from "effect/Exit";
 import type { Fx } from "../Fx.js";
 /**
- * Adds an `Effect.onExit`-style finalizer to an `Fx`.
+ * Observes the Fx's final success or failure with an Effect finalizer.
  *
- * The finalizer is run when the `Fx` terminates (success, failure, or interruption).
+ * @remarks
+ * ## Why
+ *
+ * Teardown and audit work sometimes depends on how the complete subscription
+ * ended. An `Exit` preserves that distinction without materializing it as a
+ * stream value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The finalizer runs once after successful completion, a reported source cause,
+ * or interruption of the running fiber. The success Exit carries `void`
+ * because an Fx may emit many values and has no single terminal success value.
+ * A finalizer failure after normal completion is reported in the returned error
+ * channel. After a source failure or interruption it is suppressed so the
+ * already-observed termination remains authoritative. Finalizer services live
+ * for the subscription only.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Exit } from "effect"
+ * import { onExit } from "@typed/fx/Fx"
+ * import { succeed } from "@typed/fx/Fx"
+ *
+ * const audited = onExit(succeed("ready"), (exit) =>
+ *   Effect.log(Exit.isSuccess(exit) ? "complete" : "failed")
+ * )
+ * ```
  *
  * @since 1.0.0
- * @category combinators
+ * @category Resource lifetime
  */
 export declare const onExit: {
     <A, E, XE = never, XR = never>(f: (exit: Exit.Exit<void, E>) => void | Effect.Effect<void, XE, XR>): <R>(self: Fx<A, E, R>) => Fx<A, E | XE, R | XR>;

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

@@ -1 +1 @@
-{"version":3,"file":"onExit.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onExit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAMpC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AASnC;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC3B,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAClE,CAAC,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;IAEnD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC9B,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAClE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAiD1B,CAAC"}
+{"version":3,"file":"onExit.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onExit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AACxC,OAAO,KAAK,IAAI,MAAM,aAAa,CAAC;AAMpC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AASnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,MAAM,EAAE;IACnB,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC3B,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAClE,CAAC,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;IAEnD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,EAAE,EAAE,GAAG,KAAK,EAC9B,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,KAAK,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAClE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CAiD1B,CAAC"}

package/dist/Fx/combinators/onExit.js

@@ -10,12 +10,38 @@ const toFinalizer = (f) => (exit) => {
     return Effect.isEffect(x) ? x : Effect.void;
 };
 /**
- * Adds an `Effect.onExit`-style finalizer to an `Fx`.
+ * Observes the Fx's final success or failure with an Effect finalizer.
  *
- * The finalizer is run when the `Fx` terminates (success, failure, or interruption).
+ * @remarks
+ * ## Why
+ *
+ * Teardown and audit work sometimes depends on how the complete subscription
+ * ended. An `Exit` preserves that distinction without materializing it as a
+ * stream value.
+ *
+ * ## Ownership and lifetime
+ *
+ * The finalizer runs once after successful completion, a reported source cause,
+ * or interruption of the running fiber. The success Exit carries `void`
+ * because an Fx may emit many values and has no single terminal success value.
+ * A finalizer failure after normal completion is reported in the returned error
+ * channel. After a source failure or interruption it is suppressed so the
+ * already-observed termination remains authoritative. Finalizer services live
+ * for the subscription only.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Exit } from "effect"
+ * import { onExit } from "@typed/fx/Fx"
+ * import { succeed } from "@typed/fx/Fx"
+ *
+ * const audited = onExit(succeed("ready"), (exit) =>
+ *   Effect.log(Exit.isSuccess(exit) ? "complete" : "failed")
+ * )
+ * ```
  *
  * @since 1.0.0
- * @category combinators
+ * @category Resource lifetime
  */
 export const onExit = dual(2, (self, f) => make(Effect.fnUntraced(function* (sink) {
     const finalizer = toFinalizer(f);

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

@@ -1,13 +1,58 @@
 import * as Effect from "effect/Effect";
 import type { Fx } from "../Fx.js";
 /**
- * Adds an `Effect.onInterrupt`-style finalizer to an `Fx`.
+ * Runs a finalizer when the Fx reports or externally receives interruption.
  *
- * The finalizer is run only when the stream is interrupted (either via an
- * interrupt cause or by interrupting the running fiber).
+ * @remarks
+ * ## Why
+ *
+ * Cancellation-specific cleanup should not run for success or ordinary typed
+ * failure. The interruptor IDs retain Effect's information about which fibers
+ * requested cancellation.
+ *
+ * ## Ownership and lifetime
+ *
+ * An interrupt-only Cause reported by the source invokes the finalizer before
+ * that Cause is delivered; finalizer failure is combined with it. External
+ * interruption of the running fiber also invokes the finalizer, suppressing its
+ * failure to preserve cancellation. Those paths are tracked separately: if an
+ * external interruption arrives while reported-Cause handling is still active,
+ * the finalizer can run once for each path. Successful and non-interrupt failures
+ * do not invoke it. A finalizer captured while constructing an Fx is shared by
+ * every run of that Fx; create mutable cleanup state lazily inside `gen` or
+ * `genScoped` when each subscription must own a distinct resource.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { onInterrupt } from "@typed/fx/Fx"
+ * import { interrupt } from "@typed/fx/Fx"
+ *
+ * const observed = onInterrupt(
+ *   interrupt(1),
+ *   (ids) => Effect.log(`interrupted by ${ids.size}`)
+ * )
+ * ```
+ *
+ * @example Keep the finalizer idempotent when both interrupt paths are possible
+ * ```ts
+ * import { Effect } from "effect"
+ * import { gen } from "@typed/fx/Fx"
+ * import { onInterrupt } from "@typed/fx/Fx"
+ * import { interrupt } from "@typed/fx/Fx"
+ *
+ * const observed = gen(function* () {
+ *   // `gen` creates this controller separately for every subscription.
+ *   const controller = yield* Effect.sync(() => new AbortController())
+ *   return onInterrupt(
+ *     interrupt(1),
+ *     Effect.sync(() => controller.abort()) // `abort` is idempotent.
+ *   )
+ * })
+ * ```
  *
  * @since 1.0.0
- * @category combinators
+ * @category Resource lifetime
  */
 export declare const onInterrupt: {
     <XE, XR>(finalizer: Effect.Effect<void, XE, XR> | ((interruptors: ReadonlySet<number>) => Effect.Effect<void, XE, XR>)): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E | XE, R | XR>;

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

@@ -1 +1 @@
-{"version":3,"file":"onInterrupt.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onInterrupt.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAMxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAWnC;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,CAAC,EAAE,EAAE,EAAE,EACL,SAAS,EACL,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAC3B,CAAC,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,GACvE,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;IAEzD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,SAAS,EACL,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAC3B,CAAC,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,GACvE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CA+C1B,CAAC"}
+{"version":3,"file":"onInterrupt.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/onInterrupt.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAMxC,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAWnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,WAAW,EAAE;IACxB,CAAC,EAAE,EAAE,EAAE,EACL,SAAS,EACL,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAC3B,CAAC,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,GACvE,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;IAEzD,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EACd,IAAI,EAAE,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EACjB,SAAS,EACL,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,GAC3B,CAAC,CAAC,YAAY,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,GACvE,EAAE,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;CA+C1B,CAAC"}

package/dist/Fx/combinators/onInterrupt.js

@@ -7,13 +7,58 @@ import { make as makeSink } from "../../Sink/Sink.js";
 import { make } from "../constructors/make.js";
 const toFinalizer = (f) => (interruptors) => typeof f === "function" ? f(interruptors) : f;
 /**
- * Adds an `Effect.onInterrupt`-style finalizer to an `Fx`.
+ * Runs a finalizer when the Fx reports or externally receives interruption.
  *
- * The finalizer is run only when the stream is interrupted (either via an
- * interrupt cause or by interrupting the running fiber).
+ * @remarks
+ * ## Why
+ *
+ * Cancellation-specific cleanup should not run for success or ordinary typed
+ * failure. The interruptor IDs retain Effect's information about which fibers
+ * requested cancellation.
+ *
+ * ## Ownership and lifetime
+ *
+ * An interrupt-only Cause reported by the source invokes the finalizer before
+ * that Cause is delivered; finalizer failure is combined with it. External
+ * interruption of the running fiber also invokes the finalizer, suppressing its
+ * failure to preserve cancellation. Those paths are tracked separately: if an
+ * external interruption arrives while reported-Cause handling is still active,
+ * the finalizer can run once for each path. Successful and non-interrupt failures
+ * do not invoke it. A finalizer captured while constructing an Fx is shared by
+ * every run of that Fx; create mutable cleanup state lazily inside `gen` or
+ * `genScoped` when each subscription must own a distinct resource.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { onInterrupt } from "@typed/fx/Fx"
+ * import { interrupt } from "@typed/fx/Fx"
+ *
+ * const observed = onInterrupt(
+ *   interrupt(1),
+ *   (ids) => Effect.log(`interrupted by ${ids.size}`)
+ * )
+ * ```
+ *
+ * @example Keep the finalizer idempotent when both interrupt paths are possible
+ * ```ts
+ * import { Effect } from "effect"
+ * import { gen } from "@typed/fx/Fx"
+ * import { onInterrupt } from "@typed/fx/Fx"
+ * import { interrupt } from "@typed/fx/Fx"
+ *
+ * const observed = gen(function* () {
+ *   // `gen` creates this controller separately for every subscription.
+ *   const controller = yield* Effect.sync(() => new AbortController())
+ *   return onInterrupt(
+ *     interrupt(1),
+ *     Effect.sync(() => controller.abort()) // `abort` is idempotent.
+ *   )
+ * })
+ * ```
  *
  * @since 1.0.0
- * @category combinators
+ * @category Resource lifetime
  */
 export const onInterrupt = dual(2, (self, finalizer_) => make(Effect.fnUntraced(function* (sink) {
     const finalizer = toFinalizer(finalizer_);

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

@@ -0,0 +1,28 @@
+import type { Fx } from "../Fx.js";
+/**
+ * Emits consecutive pairs `[previous, current]`. The first value is not emitted
+ * until a second value arrives.
+ *
+ * Equivalent to RxJS `pairwise` and Effect `Stream.sliding(2)` for pairs.
+ *
+ * @remarks
+ * ## Why
+ * `pairwise` exposes transitions rather than isolated values. For `n` inputs it emits `max(0,
+ * n - 1)` adjacent pairs in source order, retaining only the immediately preceding value.
+ *
+ * ## Ownership and lifetime
+ * The previous-value cell belongs to one run of the returned Fx and is discarded when that run
+ * completes or is interrupted. Source errors and services are unchanged.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const changes = Fx.fromIterable([10, 13, 12]).pipe(Fx.pairwise)
+ * ```
+ *
+ * @since 1.0.0
+ * @category Stateful transforms
+ */
+export declare const pairwise: <A, E = never, R = never>(self: Fx<A, E, R>) => Fx<readonly [A, A], E, R>;
+//# sourceMappingURL=pairwise.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.d.ts","sourceRoot":"","sources":["../../../src/Fx/combinators/pairwise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,EAAE,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAM3F,CAAC"}

package/dist/Fx/combinators/pairwise.js

@@ -0,0 +1,31 @@
+import * as Option from "effect/Option";
+import { filterMapLoop } from "./filterMapLoop.js";
+/**
+ * Emits consecutive pairs `[previous, current]`. The first value is not emitted
+ * until a second value arrives.
+ *
+ * Equivalent to RxJS `pairwise` and Effect `Stream.sliding(2)` for pairs.
+ *
+ * @remarks
+ * ## Why
+ * `pairwise` exposes transitions rather than isolated values. For `n` inputs it emits `max(0,
+ * n - 1)` adjacent pairs in source order, retaining only the immediately preceding value.
+ *
+ * ## Ownership and lifetime
+ * The previous-value cell belongs to one run of the returned Fx and is discarded when that run
+ * completes or is interrupted. Source errors and services are unchanged.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ *
+ * const changes = Fx.fromIterable([10, 13, 12]).pipe(Fx.pairwise)
+ * ```
+ *
+ * @since 1.0.0
+ * @category Stateful transforms
+ */
+export const pairwise = (self) => filterMapLoop(self, Option.none(), (prev, a) => Option.match(prev, {
+    onNone: () => [Option.none(), Option.some(a)],
+    onSome: (previous) => [Option.some([previous, a]), Option.some(a)],
+}));