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

package/dist/Fx/combinators/zip.js

@@ -0,0 +1,160 @@
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { dual } from "effect/Function";
+import * as Option from "effect/Option";
+import * as Queue from "effect/Queue";
+import { make as makeSink } from "../../Sink/Sink.js";
+import { make } from "../constructors/make.js";
+import { map } from "./map.js";
+import { tuple } from "./tuple.js";
+/**
+ * Zips two Fx streams in strict lockstep: emits a pair `[a, b]` only when both
+ * streams have produced their next value. Emits the i-th pair when both have
+ * produced at least i values.
+ *
+ * **Completion:** The zipped stream completes when the **first** of the two
+ * streams completes (no further pairs are emitted). The other stream is
+ * interrupted.
+ *
+ * **Errors:** The first failure from either stream fails the zipped stream.
+ *
+ * @remarks
+ * ## Why
+ * `zip` preserves one-to-one positional correspondence between two producers. Values wait in
+ * unbounded queues until their counterpart arrives, and pairs emit in each source's order.
+ *
+ * ## Ownership and lifetime
+ * Both child runs and queues belong to the consumer. The first completion, any failure, or
+ * interruption stops both fibers and discards unmatched queued values.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const pairs = Fx.zip(Fx.fromIterable([1, 2]), Fx.fromIterable(["a", "b"]))
+ * ```
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits pairs `[A, B]`.
+ * @since 1.0.0
+ * @category Combining sources
+ */
+export const zip = dual(2, (self, that) => make((sink) => Effect.gen(function* () {
+    const leftQueue = yield* Queue.unbounded();
+    const rightQueue = yield* Queue.unbounded();
+    const leftSink = makeSink(sink.onFailure, (a) => Queue.offer(leftQueue, Option.some(a)));
+    const rightSink = makeSink(sink.onFailure, (b) => Queue.offer(rightQueue, Option.some(b)));
+    const runLeft = self
+        .run(leftSink)
+        .pipe(Effect.ensuring(Queue.offer(leftQueue, Option.none())));
+    const runRight = that
+        .run(rightSink)
+        .pipe(Effect.ensuring(Queue.offer(rightQueue, Option.none())));
+    const consumer = Effect.gen(function* () {
+        while (true) {
+            const exitA = yield* Effect.exit(Queue.take(leftQueue));
+            if (Exit.isFailure(exitA))
+                return;
+            if (Option.isNone(exitA.value))
+                return;
+            const exitB = yield* Effect.exit(Queue.take(rightQueue));
+            if (Exit.isFailure(exitB))
+                return;
+            if (Option.isNone(exitB.value))
+                return;
+            yield* sink.onSuccess([exitA.value.value, exitB.value.value]);
+        }
+    });
+    const leftFiber = yield* Effect.forkChild(runLeft);
+    const rightFiber = yield* Effect.forkChild(runRight);
+    yield* consumer.pipe(Effect.ensuring(Fiber.interrupt(leftFiber)), Effect.ensuring(Fiber.interrupt(rightFiber)));
+})));
+/**
+ * Zips two Fx streams in strict lockstep and combines each pair with a function.
+ * Emits `f(a, b)` when both streams have produced their next value.
+ *
+ * **Completion:** Completes when the **first** of the two streams completes.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @remarks
+ * ## Why
+ * `zipWith` combines each strict pair immediately, preserving `zip`'s lockstep cardinality and
+ * ordering while avoiding a separate tuple mapping step.
+ *
+ * ## Ownership and lifetime
+ * It inherits `zip`'s two child runs and unbounded unmatched-value queues. The pure combiner adds no
+ * resource, error, or service requirement.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const sums = Fx.zipWith(Fx.fromIterable([1]), Fx.fromIterable([2]), (a, b) => a + b)
+ * ```
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the pair `(a, b)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category Combining sources
+ */
+export const zipWith = dual(3, (self, that, f) => map(zip(self, that), (pair) => f(pair[0], pair[1])));
+/**
+ * Zips two Fx streams by latest values: waits for both to emit at least once,
+ * then emits `[left, right]` whenever **either** stream emits (using the latest
+ * value from the other). No strict pairing; output count is the sum of
+ * emissions from both after the first pair.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @remarks
+ * ## Why
+ * `zipLatest` combines independent sources as state: after both initialize, either update emits one
+ * pair containing both latest values. It does not enforce one-to-one pairing.
+ *
+ * ## Ownership and lifetime
+ * It delegates to `tuple`: both sources run concurrently and retain one latest value each until
+ * both complete or the consumer is interrupted.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const latest = Fx.zipLatest(Fx.succeed(1), Fx.succeed("ready"))
+ * ```
+ *
+ * @param that - The second Fx stream.
+ * @returns An Fx that emits `[AL, AR]` on every update from either stream.
+ * @since 1.0.0
+ * @category Combining sources
+ */
+export const zipLatest = dual(2, (self, that) => tuple(self, that));
+/**
+ * Zips two Fx streams by latest values and combines each pair with a function.
+ * Waits for both to emit at least once, then emits `f(left, right)` whenever
+ * either stream emits.
+ *
+ * **Completion:** Completes when **both** streams have completed.
+ * **Errors:** The first failure from either stream fails the result.
+ *
+ * @remarks
+ * ## Why
+ * `zipLatestWith` projects latest-value pairs whenever either initialized source updates. The
+ * synchronous callback changes payloads without changing `zipLatest` cardinality.
+ *
+ * ## Ownership and lifetime
+ * Both concurrent sources and their retained latest values are owned by the consumer. The combiner
+ * is pure; failure, services, completion, and interruption come from the inputs.
+ *
+ * @example
+ * ```ts
+ * import { Fx } from "@typed/fx"
+ * const label = Fx.zipLatestWith(Fx.succeed(1), Fx.succeed("item"), (n, kind) => `${kind}-${n}`)
+ * ```
+ *
+ * @param that - The second Fx stream.
+ * @param f - Function to combine the latest `(left, right)` into a single value.
+ * @returns An Fx that emits combined values.
+ * @since 1.0.0
+ * @category Combining sources
+ */
+export const zipLatestWith = dual(3, (self, that, f) => map(zipLatest(self, that), (pair) => f(pair[0], pair[1])));

package/dist/Fx/constructors/at.d.ts

@@ -3,14 +3,34 @@ import type { Fx } from "../Fx.js";
 /**
  * Creates an Fx that emits a single value after a specified delay.
  *
+ * @remarks
+ * ## Why
+ *
+ * `at` models a one-shot producer while keeping the delay inside Effect's
+ * interruptible scheduling rather than an unmanaged timer callback.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction starts no timer. Running the `Fx` sleeps, emits exactly once, and
+ * completes after the sink handles the value. Interrupting the run cancels the sleep.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { at, first } from "@typed/fx/Fx"
+ *
+ * const delayed = at("ready", "10 millis")
+ * const program = Effect.map(first(delayed), (value) => value)
+ * ```
+ *
  * @param value - The value to emit.
  * @param delay - The duration to wait before emitting.
  * @returns An `Fx` that emits the value after the delay.
  * @since 1.0.0
- * @category constructors
+ * @category Time and rate
  */
 export declare const at: {
-    (delay: Duration.DurationInput): <A>(value: A) => Fx<A>;
-    <A>(value: A, delay: Duration.DurationInput): Fx<A>;
+    (delay: Duration.Input): <A>(value: A) => Fx<A>;
+    <A>(value: A, delay: Duration.Input): Fx<A>;
 };
 //# sourceMappingURL=at.d.ts.map

package/dist/Fx/constructors/at.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"at.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/at.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;GAQG;AACH,eAAO,MAAM,EAAE,EAAE;IACf,CAAC,KAAK,EAAE,QAAQ,CAAC,aAAa,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IACxD,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,aAAa,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;CAKrD,CAAC"}
+{"version":3,"file":"at.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/at.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAGjD,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,EAAE,EAAE;IACf,CAAC,KAAK,EAAE,QAAQ,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,CAAC,KAAK,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;CAK7C,CAAC"}

package/dist/Fx/constructors/at.js

@@ -4,10 +4,30 @@ import { make } from "./make.js";
 /**
  * Creates an Fx that emits a single value after a specified delay.
  *
+ * @remarks
+ * ## Why
+ *
+ * `at` models a one-shot producer while keeping the delay inside Effect's
+ * interruptible scheduling rather than an unmanaged timer callback.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction starts no timer. Running the `Fx` sleeps, emits exactly once, and
+ * completes after the sink handles the value. Interrupting the run cancels the sleep.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { at, first } from "@typed/fx/Fx"
+ *
+ * const delayed = at("ready", "10 millis")
+ * const program = Effect.map(first(delayed), (value) => value)
+ * ```
+ *
  * @param value - The value to emit.
  * @param delay - The duration to wait before emitting.
  * @returns An `Fx` that emits the value after the delay.
  * @since 1.0.0
- * @category constructors
+ * @category Time and rate
  */
 export const at = dual(2, (value, delay) => make((sink) => flatMap(sleep(delay), () => sink.onSuccess(value))));

package/dist/Fx/constructors/die.d.ts

@@ -2,10 +2,31 @@ import type { Fx } from "../Fx.js";
 /**
  * Creates an Fx that immediately terminates with a defect (unexpected error).
  *
+ * @remarks
+ * ## Why
+ *
+ * Defects represent unexpected, non-recoverable failures and remain distinct from
+ * the typed `E` channel.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction is inert. Each run delivers one defect cause to the sink and emits
+ * no values; it acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Cause, Effect } from "effect"
+ * import { die, observe } from "@typed/fx/Fx"
+ *
+ * const program = observe(die(new Error("broken")), () => Effect.void).pipe(
+ *   Effect.catchCause((cause) => Effect.succeed(Cause.hasDies(cause)))
+ * )
+ * ```
+ *
  * @param defect - The defect value.
  * @returns An `Fx` that dies immediately.
  * @since 1.0.0
- * @category constructors
+ * @category Failure sources
  */
 export declare const die: (defect: unknown) => Fx<never, never, never>;
 //# sourceMappingURL=die.d.ts.map

package/dist/Fx/constructors/die.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"die.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/die.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;GAOG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAG5D,CAAC"}
+{"version":3,"file":"die.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/die.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,GAAG,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAG5D,CAAC"}

package/dist/Fx/constructors/die.js

@@ -4,9 +4,30 @@ import { failCause } from "./failCause.js";
 /**
  * Creates an Fx that immediately terminates with a defect (unexpected error).
  *
+ * @remarks
+ * ## Why
+ *
+ * Defects represent unexpected, non-recoverable failures and remain distinct from
+ * the typed `E` channel.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction is inert. Each run delivers one defect cause to the sink and emits
+ * no values; it acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Cause, Effect } from "effect"
+ * import { die, observe } from "@typed/fx/Fx"
+ *
+ * const program = observe(die(new Error("broken")), () => Effect.void).pipe(
+ *   Effect.catchCause((cause) => Effect.succeed(Cause.hasDies(cause)))
+ * )
+ * ```
+ *
  * @param defect - The defect value.
  * @returns An `Fx` that dies immediately.
  * @since 1.0.0
- * @category constructors
+ * @category Failure sources
  */
 export const die = /*#__PURE__*/ flow(Cause.die, failCause);

package/dist/Fx/constructors/empty.d.ts

@@ -1,8 +1,26 @@
 import type { Fx } from "../Fx.js";
 /**
  * An Fx that emits no values and completes immediately.
+ *
+ * @remarks
+ * ## Why
+ *
+ * `empty` is the zero-emission producer used for conditional and identity branches.
+ *
+ * ## Ownership and lifetime
+ *
+ * Each run completes synchronously, emits nothing, and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import { empty, first } from "@typed/fx/Fx"
+ *
+ * const program = Effect.map(first(empty), Option.isNone)
+ * ```
+ *
  * @since 1.0.0
- * @category constructors
+ * @category Value sources
  */
 export declare const empty: Fx<never, never, never>;
 //# sourceMappingURL=empty.d.ts.map

package/dist/Fx/constructors/empty.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"empty.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/empty.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;GAIG;AACH,eAAO,MAAM,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAA0C,CAAC"}
+{"version":3,"file":"empty.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/empty.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,KAAK,EAAE,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAA0C,CAAC"}

package/dist/Fx/constructors/empty.js

@@ -2,7 +2,25 @@ import { void as void_ } from "effect/Effect";
 import { make } from "./make.js";
 /**
  * An Fx that emits no values and completes immediately.
+ *
+ * @remarks
+ * ## Why
+ *
+ * `empty` is the zero-emission producer used for conditional and identity branches.
+ *
+ * ## Ownership and lifetime
+ *
+ * Each run completes synchronously, emits nothing, and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Option } from "effect"
+ * import { empty, first } from "@typed/fx/Fx"
+ *
+ * const program = Effect.map(first(empty), Option.isNone)
+ * ```
+ *
  * @since 1.0.0
- * @category constructors
+ * @category Value sources
  */
 export const empty = make(() => void_);

package/dist/Fx/constructors/fail.d.ts

@@ -2,10 +2,31 @@ import type { Fx } from "../Fx.js";
 /**
  * Creates an Fx that immediately fails with the specified error.
  *
+ * @remarks
+ * ## Why
+ *
+ * `fail` introduces an expected domain error into the typed `E` channel without
+ * emitting a value.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction is inert. Each run delivers one typed failure cause to the sink and
+ * acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { fail, first } from "@typed/fx/Fx"
+ *
+ * const program = first(fail("offline")).pipe(
+ *   Effect.catch((error) => Effect.succeed(`failed: ${error}`))
+ * )
+ * ```
+ *
  * @param error - The error to fail with.
  * @returns An `Fx` that fails immediately.
  * @since 1.0.0
- * @category constructors
+ * @category Failure sources
  */
 export declare const fail: <E>(error: E) => Fx<never, E, never>;
 //# sourceMappingURL=fail.d.ts.map

package/dist/Fx/constructors/fail.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/fail.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAA6C,CAAC"}
+{"version":3,"file":"fail.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/fail.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI,EAAE,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CAA6C,CAAC"}

package/dist/Fx/constructors/fail.js

@@ -4,9 +4,30 @@ import { failCause } from "./failCause.js";
 /**
  * Creates an Fx that immediately fails with the specified error.
  *
+ * @remarks
+ * ## Why
+ *
+ * `fail` introduces an expected domain error into the typed `E` channel without
+ * emitting a value.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction is inert. Each run delivers one typed failure cause to the sink and
+ * acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { fail, first } from "@typed/fx/Fx"
+ *
+ * const program = first(fail("offline")).pipe(
+ *   Effect.catch((error) => Effect.succeed(`failed: ${error}`))
+ * )
+ * ```
+ *
  * @param error - The error to fail with.
  * @returns An `Fx` that fails immediately.
  * @since 1.0.0
- * @category constructors
+ * @category Failure sources
  */
 export const fail = /*#__PURE__*/ flow(Cause.fail, failCause);

package/dist/Fx/constructors/failCause.d.ts

@@ -3,10 +3,32 @@ import type { Fx } from "../Fx.js";
 /**
  * Creates an Fx that immediately terminates with the specified Cause.
  *
+ * @remarks
+ * ## Why
+ *
+ * A complete Effect `Cause` can carry typed failures, defects, and interruption
+ * information across an `Fx` boundary without flattening that structure.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction is inert. Each run forwards the cause once to `sink.onFailure`, emits
+ * no values, and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Cause, Effect } from "effect"
+ * import { failCause, observe } from "@typed/fx/Fx"
+ *
+ * const source = failCause(Cause.fail("offline"))
+ * const program = observe(source, () => Effect.void).pipe(
+ *   Effect.catch((error) => Effect.succeed(error))
+ * )
+ * ```
+ *
  * @param cause - The cause of failure.
  * @returns An `Fx` that terminates with the given cause.
  * @since 1.0.0
- * @category constructors
+ * @category Failure sources
  */
 export declare const failCause: <E>(cause: Cause.Cause<E>) => Fx<never, E, never>;
 //# sourceMappingURL=failCause.d.ts.map

package/dist/Fx/constructors/failCause.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"failCause.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/failCause.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,EAAE,OAAO,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAG,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CACD,CAAC"}
+{"version":3,"file":"failCause.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/failCause.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,SAAS,GAAI,CAAC,SAAS,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,KAAG,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,CACD,CAAC"}

package/dist/Fx/constructors/failCause.js

@@ -2,10 +2,32 @@ import { make } from "./make.js";
 /**
  * Creates an Fx that immediately terminates with the specified Cause.
  *
+ * @remarks
+ * ## Why
+ *
+ * A complete Effect `Cause` can carry typed failures, defects, and interruption
+ * information across an `Fx` boundary without flattening that structure.
+ *
+ * ## Ownership and lifetime
+ *
+ * Construction is inert. Each run forwards the cause once to `sink.onFailure`, emits
+ * no values, and acquires no resources.
+ *
+ * @example
+ * ```ts
+ * import { Cause, Effect } from "effect"
+ * import { failCause, observe } from "@typed/fx/Fx"
+ *
+ * const source = failCause(Cause.fail("offline"))
+ * const program = observe(source, () => Effect.void).pipe(
+ *   Effect.catch((error) => Effect.succeed(error))
+ * )
+ * ```
+ *
  * @param cause - The cause of failure.
  * @returns An `Fx` that terminates with the given cause.
  * @since 1.0.0
- * @category constructors
+ * @category Failure sources
  */
 export const failCause = (cause) => 
 /*#__PURE__*/ make((sink) => sink.onFailure(cause));