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

package/package.json

@@ -1,29 +1,143 @@
 {
   "name": "@typed/fx",
-  "version": "2.0.0-beta.0",
-  "publishConfig": {
-    "access": "public"
+  "version": "2.0.0-beta.10",
+  "description": "Reactive streams and state for Typed applications.",
+  "homepage": "https://github.com/TylorS/typed/tree/development/packages/fx#readme",
+  "bugs": "https://github.com/TylorS/typed/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TylorS/typed.git",
+    "directory": "packages/fx"
   },
+  "files": [
+    "dist"
+  ],
   "type": "module",
+  "sideEffects": false,
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./*": {
-      "types": "./dist/*.d.ts",
-      "import": "./dist/*.js"
+    "./Fx": {
+      "types": "./dist/Fx.d.ts",
+      "import": "./dist/Fx.js"
+    },
+    "./Push": {
+      "types": "./dist/Push.d.ts",
+      "import": "./dist/Push.js"
+    },
+    "./RefSubject": {
+      "types": "./dist/RefSubject.d.ts",
+      "import": "./dist/RefSubject.js"
+    },
+    "./Sink": {
+      "types": "./dist/Sink.d.ts",
+      "import": "./dist/Sink.js"
+    },
+    "./Subject": {
+      "types": "./dist/Subject.d.ts",
+      "import": "./dist/Subject.js"
+    },
+    "./Versioned": {
+      "types": "./dist/Versioned.d.ts",
+      "import": "./dist/Versioned.js"
+    },
+    "./RefArray": {
+      "types": "./dist/RefArray.d.ts",
+      "import": "./dist/RefArray.js"
+    },
+    "./RefBigDecimal": {
+      "types": "./dist/RefBigDecimal.d.ts",
+      "import": "./dist/RefBigDecimal.js"
+    },
+    "./RefBigInt": {
+      "types": "./dist/RefBigInt.d.ts",
+      "import": "./dist/RefBigInt.js"
+    },
+    "./RefBoolean": {
+      "types": "./dist/RefBoolean.d.ts",
+      "import": "./dist/RefBoolean.js"
+    },
+    "./RefCause": {
+      "types": "./dist/RefCause.d.ts",
+      "import": "./dist/RefCause.js"
+    },
+    "./RefChunk": {
+      "types": "./dist/RefChunk.d.ts",
+      "import": "./dist/RefChunk.js"
+    },
+    "./RefDateTime": {
+      "types": "./dist/RefDateTime.d.ts",
+      "import": "./dist/RefDateTime.js"
+    },
+    "./RefDuration": {
+      "types": "./dist/RefDuration.d.ts",
+      "import": "./dist/RefDuration.js"
+    },
+    "./RefGraph": {
+      "types": "./dist/RefGraph.d.ts",
+      "import": "./dist/RefGraph.js"
+    },
+    "./RefHashMap": {
+      "types": "./dist/RefHashMap.d.ts",
+      "import": "./dist/RefHashMap.js"
+    },
+    "./RefHashRing": {
+      "types": "./dist/RefHashRing.d.ts",
+      "import": "./dist/RefHashRing.js"
+    },
+    "./RefHashSet": {
+      "types": "./dist/RefHashSet.d.ts",
+      "import": "./dist/RefHashSet.js"
+    },
+    "./RefIterable": {
+      "types": "./dist/RefIterable.d.ts",
+      "import": "./dist/RefIterable.js"
+    },
+    "./RefOption": {
+      "types": "./dist/RefOption.d.ts",
+      "import": "./dist/RefOption.js"
+    },
+    "./RefRecord": {
+      "types": "./dist/RefRecord.d.ts",
+      "import": "./dist/RefRecord.js"
+    },
+    "./RefResult": {
+      "types": "./dist/RefResult.d.ts",
+      "import": "./dist/RefResult.js"
+    },
+    "./RefString": {
+      "types": "./dist/RefString.d.ts",
+      "import": "./dist/RefString.js"
+    },
+    "./RefStruct": {
+      "types": "./dist/RefStruct.d.ts",
+      "import": "./dist/RefStruct.js"
+    },
+    "./RefTrie": {
+      "types": "./dist/RefTrie.d.ts",
+      "import": "./dist/RefTrie.js"
+    },
+    "./RefTuple": {
+      "types": "./dist/RefTuple.d.ts",
+      "import": "./dist/RefTuple.js"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "effect": "4.0.0-beta.4"
+    "effect": "4.0.0-rc.112"
   },
   "devDependencies": {
-    "typescript": "5.9.3",
-    "vitest": "4.0.18"
+    "typescript": "7.0.2",
+    "vitest": "5.0.0"
   },
   "scripts": {
-    "build": "tsc",
-    "test": "vitest run --passWithNoTests"
+    "build": "node -e \"const fs=require('node:fs'); fs.rmSync('dist',{recursive:true,force:true}); fs.rmSync('tsconfig.tsbuildinfo',{force:true})\" && tsc",
+    "test": "vitest run --config vitest.config.ts",
+    "test:types": "pnpm run build && tsc -p tsconfig.type-tests.json && tsc -p tsconfig.tests.json"
   }
 }

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

@@ -1,12 +0,0 @@
-import type { Yieldable } from "effect/Effect";
-import type { Fx } from "../Fx.js";
-/**
- * Creates an Fx from any Yieldable value (e.g., Effect, Promise, etc.).
- *
- * @param yieldable - The yieldable value to convert.
- * @returns An `Fx` that emits the result of the yieldable.
- * @since 1.0.0
- * @category constructors
- */
-export declare const fromYieldable: <A, E = never, R = never>(yieldable: Yieldable<any, A, E, R>) => Fx<A, E, R>;
-//# sourceMappingURL=fromYieldable.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"fromYieldable.d.ts","sourceRoot":"","sources":["../../../src/Fx/constructors/fromYieldable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,UAAU,CAAC;AAGnC;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,EACnD,WAAW,SAAS,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KACjC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CACwE,CAAC"}

package/dist/Fx/constructors/fromYieldable.js

@@ -1,12 +0,0 @@
-import { matchCauseEffect } from "effect/Effect";
-import { make } from "./make.js";
-/**
- * Creates an Fx from any Yieldable value (e.g., Effect, Promise, etc.).
- *
- * @param yieldable - The yieldable value to convert.
- * @returns An `Fx` that emits the result of the yieldable.
- * @since 1.0.0
- * @category constructors
- */
-export const fromYieldable = (yieldable) => 
-/*#__PURE__*/ make((sink) => matchCauseEffect(yieldable.asEffect(), sink));

package/src/Fx/Fx.ts

@@ -1,164 +0,0 @@
-import * as Effect from "effect/Effect";
-import { identity } from "effect/Function";
-import type { Layer } from "effect/Layer";
-import { effect } from "effect/Layer";
-import { type Pipeable, pipeArguments } from "effect/Pipeable";
-import type * as Scope from "effect/Scope";
-import * as ServiceMap from "effect/ServiceMap";
-import type * as Types from "effect/Types";
-import type * as Sink from "../Sink/Sink.js";
-import { provideServices } from "./combinators/provide.js";
-import { FxTypeId, isFx } from "./TypeId.js";
-
-/**
- * `Fx` is a reactive stream of values that supports concurrency, error handling,
- * and context management, fully integrated with the Effect ecosystem.
- *
- * Conceptually, an `Fx<A, E, R>` is a push-based stream that:
- * - Emits values of type `A`
- * - Can fail with an error of type `E`
- * - Requires a context/environment of type `R`
- *
- * Unlike a standard `Effect` which produces a single value, `Fx` can produce
- * 0, 1, or many values over time. It is similar to RxJS Observables or
- * AsyncIterables, but built on top of Effect's fiber-based concurrency model.
- *
- * @since 1.0.0
- * @category models
- */
-export interface Fx<A, E = never, R = never> extends Pipeable {
-  readonly [FxTypeId]: Fx.Variance<A, E, R>;
-  /**
-   * Runs the Fx stream by providing a Sink to consume the values.
-   * The result is an Effect that runs the stream process.
-   */
-  readonly run: <RSink>(sink: Sink.Sink<A, E, RSink>) => Effect.Effect<unknown, never, R | RSink>;
-}
-
-export declare namespace Fx {
-  /**
-   * Any Fx type with wildcards.
-   * @since 1.0.0
-   * @category models
-   */
-  export type Any = Fx<any, any, any>;
-
-  /**
-   * Variance markers for Fx types.
-   * @since 1.0.0
-   * @category models
-   */
-  export interface Variance<A, E, R> {
-    readonly _A: Types.Covariant<A>;
-    readonly _E: Types.Covariant<E>;
-    readonly _R: Types.Covariant<R>;
-  }
-
-  /**
-   * Extract the success type from an Fx.
-   * @since 1.0.0
-   * @category type-level
-   */
-  export type Success<T> = [T] extends [never]
-    ? never
-    : T extends Fx<infer _A, infer _E, infer _R>
-      ? _A
-      : never;
-
-  /**
-   * Extract the error type from an Fx.
-   * @since 1.0.0
-   * @category type-level
-   */
-  export type Error<T> = [T] extends [never]
-    ? never
-    : T extends Fx<infer _A, infer _E, infer _R>
-      ? _E
-      : never;
-
-  /**
-   * Extract the required services from an Fx.
-   * @since 1.0.0
-   * @category type-level
-   */
-  export type Services<T> = [T] extends [never]
-    ? never
-    : [T] extends [Fx<infer _A, infer _E, infer _R>]
-      ? _R
-      : never;
-
-  export interface Service<Self, Id extends string, A, E> extends Fx<A, E, Self> {
-    readonly id: Id;
-    readonly service: ServiceMap.Service<Self, Fx<A, E>>;
-    readonly make: <R = never>(
-      fx: Fx<A, E, R> | Effect.Effect<Fx<A, E, R>, E, R>,
-    ) => Layer<Self, E, Exclude<R, Scope.Scope>>;
-  }
-
-  export interface Class<Self, Id extends string, A, E> extends Service<Self, Id, A, E> {
-    new (): Service<Self, Id, A, E>;
-  }
-}
-
-/**
- * Extract the success type from an Fx.
- * @since 1.0.0
- * @category type-level
- */
-export type Success<T> = Fx.Success<T>;
-
-/**
- * Extract the error type from an Fx.
- * @since 1.0.0
- * @category type-level
- */
-export type Error<T> = Fx.Error<T>;
-
-/**
- * Extract the required services from an Fx.
- * @since 1.0.0
- * @category type-level
- */
-export type Services<T> = Fx.Services<T>;
-
-const VARIANCE: Fx.Variance<any, any, any> = {
-  _A: identity,
-  _E: identity,
-  _R: identity,
-};
-
-export function Service<Self, A, E = never>() {
-  return <const Id extends string>(id: Id): Fx.Class<Self, Id, A, E> => {
-    const service = ServiceMap.Service<Self, Fx<A, E>>(id);
-
-    // eslint-disable-next-line @typescript-eslint/no-extraneous-class
-    return class FxService {
-      static readonly id = id;
-      static readonly service = service;
-
-      static readonly make = <R = never>(
-        fx: Fx<A, E, R> | Effect.Effect<Fx<A, E, R>, E, R>,
-      ): Layer<Self, E, Exclude<R, Scope.Scope>> =>
-        effect(
-          service,
-          Effect.gen(function* () {
-            const services = yield* Effect.services<R>();
-            const result = isFx(fx) ? fx : yield* fx;
-            return provideServices(result, services);
-          }),
-        );
-
-      static readonly [FxTypeId] = VARIANCE;
-      static readonly pipe = function (this: any) {
-        return pipeArguments(this, arguments);
-      };
-
-      static readonly run = <RSink>(sink: Sink.Sink<A, E, RSink>) =>
-        Effect.flatMap(service.asEffect(), (fx) => fx.run(sink));
-
-      constructor() {
-        return FxService;
-      }
-    } as unknown as Fx.Class<Self, Id, A, E>;
-  };
-}

package/src/Fx/TypeId.ts

@@ -1,25 +0,0 @@
-import { hasProperty } from "effect/Predicate";
-import type { Fx } from "./Fx.js";
-
-/**
- * The unique type identifier for Fx.
- * @since 1.0.0
- * @category symbol
- */
-export const FxTypeId = Symbol.for("@typed/fx/Fx");
-
-/**
- * The unique type identifier type for Fx.
- * @since 1.0.0
- * @category symbol
- */
-export type FxTypeId = typeof FxTypeId;
-
-/**
- * Checks if a value is an Fx.
- * @since 1.0.0
- * @category guards
- */
-export function isFx(u: unknown): u is Fx<any, any, any> {
-  return hasProperty(u, FxTypeId);
-}

package/src/Fx/combinators/catch.ts

@@ -1,165 +0,0 @@
-import type * as Arr from "effect/Array";
-import * as Cause from "effect/Cause";
-import { dual } from "effect/Function";
-import * as Result from "effect/Result";
-import type { ExcludeTag, ExtractTag, NoInfer, Tags } from "effect/Types";
-import { make as makeSink } from "../../Sink/Sink.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-const hasTag = (u: unknown): u is { readonly _tag: string } =>
-  typeof u === "object" &&
-  u !== null &&
-  "_tag" in u &&
-  typeof (u as Record<string, unknown>)["_tag"] === "string";
-
-const matchesTag = <E, K extends string>(
-  tag: K | Arr.NonEmptyReadonlyArray<K>,
-  error: E,
-): error is ExtractTag<E, K> => {
-  if (!hasTag(error)) return false;
-  if (typeof tag === "string") return error._tag === tag;
-  return tag.some((t) => t === error._tag);
-};
-
-/**
- * Recovers from a typed failure of an Fx by switching to a fallback Fx.
- *
- * Mirrors `Effect.catch` / `Effect.catchAll` (catches `Cause.Fail` only).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catch_: {
-  <E, A2, E2, R2>(f: (e: E) => Fx<A2, E2, R2>): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
-
-  <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2>(self: Fx<A, E, R>, f: (e: E) => Fx<A2, E2, R2>): Fx<A | A2, E2, R | R2> =>
-    make<A | A2, E2, R | R2>((sink) =>
-      self.run(
-        makeSink((cause) => {
-          const result = Cause.findFail(cause);
-          if (Result.isFailure(result)) {
-            return sink.onFailure(result.failure);
-          }
-          return f(result.success.error).run(sink);
-        }, sink.onSuccess),
-      ),
-    ),
-);
-
-export { catch_ as catch };
-
-/**
- * An alias for {@link catch}.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchAll = catch_;
-
-/**
- * Recovers from *any* failure cause of an Fx (including defects and interrupts)
- * by switching to a fallback Fx.
- *
- * Mirrors `Effect.catchCause`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchCause: {
-  <E, A2, E2, R2>(
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): <A, R>(self: Fx<A, E, R>) => Fx<A | A2, E2, R | R2>;
-
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    f: (cause: Cause.Cause<E>) => Fx<A2, E2, R2>,
-  ): Fx<A | A2, E2, R | R2> =>
-    make<A | A2, E2, R | R2>((sink) =>
-      self.run(makeSink((cause) => f(cause).run(sink), sink.onSuccess)),
-    ),
-);
-
-/**
- * Recovers from a typed failure by matching on the `_tag` field of the error.
- *
- * Mirrors `Effect.catchTag`.
- *
- * @since 1.0.0
- * @category combinators
- */
-export const catchTag: {
-  <const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, E, A2, E2, R2>(
-    k: K,
-    f: (
-      e: ExtractTag<NoInfer<E>, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    ) => Fx<A2, E2, R2>,
-  ): <A, R>(
-    self: Fx<A, E, R>,
-  ) => Fx<
-    A | A2,
-    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    R | R2
-  >;
-
-  <A, E, R, const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    k: K,
-    f: (
-      e: ExtractTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    ) => Fx<A2, E2, R2>,
-  ): Fx<
-    A | A2,
-    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    R | R2
-  >;
-} = dual(
-  3,
-  <A, E, R, const K extends Tags<E> | Arr.NonEmptyReadonlyArray<Tags<E>>, A2, E2, R2>(
-    self: Fx<A, E, R>,
-    k: K,
-    f: (
-      e: ExtractTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    ) => Fx<A2, E2, R2>,
-  ): Fx<
-    A | A2,
-    E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-    R | R2
-  > =>
-    make<
-      A | A2,
-      E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>,
-      R | R2
-    >((sink) =>
-      self.run(
-        makeSink((cause) => {
-          const result = Cause.findFail(cause);
-          if (Result.isFailure(result)) {
-            return sink.onFailure(result.failure);
-          } else if (matchesTag(k, result.success.error)) {
-            return f(
-              result.success.error as ExtractTag<
-                E,
-                K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K
-              >,
-            ).run(sink);
-          } else {
-            return sink.onFailure(
-              cause as Cause.Cause<
-                E2 | ExcludeTag<E, K extends Arr.NonEmptyReadonlyArray<string> ? K[number] : K>
-              >,
-            );
-          }
-        }, sink.onSuccess),
-      ),
-    ),
-);

package/src/Fx/combinators/causes.ts

@@ -1,23 +0,0 @@
-import type * as Cause from "effect/Cause";
-import * as Exit from "effect/Exit";
-import * as Option from "effect/Option";
-import type { Fx } from "../Fx.js";
-import { exit } from "./exit.js";
-import { filterMap } from "./filterMap.js";
-
-/**
- * Emits only the failure causes from an Fx, discarding successful values.
- *
- * @param fx - The `Fx` stream.
- * @returns An `Fx` emitting `Cause<E>`.
- * @since 1.0.0
- * @category combinators
- */
-export const causes = <A, E, R>(fx: Fx<A, E, R>): Fx<Cause.Cause<E>, never, R> =>
-  filterMap(
-    exit(fx),
-    Exit.match({
-      onFailure: Option.some,
-      onSuccess: Option.none,
-    }),
-  );

package/src/Fx/combinators/compact.ts

@@ -1,15 +0,0 @@
-import type * as Option from "effect/Option";
-import * as sinkCore from "../../Sink/combinators.js";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Compacts an Fx of Options, discarding `None` values and unwrapping `Some` values.
- *
- * @param self - An `Fx` emitting `Option<A>`.
- * @returns An `Fx` emitting `A`.
- * @since 1.0.0
- * @category combinators
- */
-export const compact = <A, E, R>(self: Fx<Option.Option<A>, E, R>): Fx<A, E, R> =>
-  make<A, E, R>((sink) => self.run(sinkCore.compact(sink)));

package/src/Fx/combinators/continueWith.ts

@@ -1,78 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import { make } from "../constructors/make.js";
-import { succeed } from "../constructors/succeed.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * continues an Fx with another Fx after the first one completes.
- *
- * @param f - A function that returns the next Fx to run.
- * @returns An `Fx` that emits values from the first Fx, then from the second Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const continueWith: {
-  <B, E2, R2>(f: () => Fx<B, E2, R2>): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E | E2, R | R2>;
-
-  <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2>;
-} = dual(
-  2,
-  <A, E, R, B, E2, R2>(fx: Fx<A, E, R>, f: () => Fx<B, E2, R2>): Fx<A | B, E | E2, R | R2> =>
-    make<A | B, E | E2, R | R2>((sink) => Effect.flatMap(fx.run(sink), () => f().run(sink))),
-);
-
-/**
- * Appends a value to the end of an Fx.
- *
- * @param value - The value to append.
- * @returns An `Fx` that emits values from the input Fx, then the appended value.
- * @since 1.0.0
- * @category combinators
- */
-export const append: {
-  <B>(value: B): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B, E, R>;
-
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<A | B, E, R>;
-} = dual(
-  2,
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<A | B, E, R> =>
-    continueWith(fx, () => succeed(value)),
-);
-
-/**
- * Prepends a value to the beginning of an Fx.
- *
- * @param value - The value to prepend.
- * @returns An `Fx` that emits the prepended value, then values from the input Fx.
- * @since 1.0.0
- * @category combinators
- */
-export const prepend: {
-  <B>(value: B): <A, E, R>(fx: Fx<A, E, R>) => Fx<B | A, E, R>;
-
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<B | A, E, R>;
-} = dual(
-  2,
-  <A, E, R, B>(fx: Fx<A, E, R>, value: B): Fx<B | A, E, R> =>
-    continueWith(succeed(value), () => fx),
-);
-
-/**
- * Wraps an Fx with a start and end value.
- *
- * @param before - The value to emit before the Fx starts.
- * @param after - The value to emit after the Fx completes.
- * @returns An `Fx` that emits `before`, then values from the input Fx, then `after`.
- * @since 1.0.0
- * @category combinators
- */
-export const delimit: {
-  <B, C>(before: B, after: C): <A, E, R>(fx: Fx<A, E, R>) => Fx<A | B | C, E, R>;
-
-  <A, E, R, B, C>(fx: Fx<A, E, R>, before: B, after: C): Fx<A | B | C, E, R>;
-} = dual(
-  3,
-  <A, E, R, B, C>(fx: Fx<A, E, R>, before: B, after: C): Fx<A | B | C, E, R> =>
-    fx.pipe(prepend(before), append(after)),
-);

package/src/Fx/combinators/ensuring.ts

@@ -1,23 +0,0 @@
-import * as Effect from "effect/Effect";
-import { dual } from "effect/Function";
-import { make } from "../constructors/make.js";
-import type { Fx } from "../Fx.js";
-
-/**
- * Adds an `Effect.ensuring`-style finalizer to an `Fx`.
- *
- * The finalizer is guaranteed to run when the stream terminates (success,
- * failure, or interruption).
- *
- * @since 1.0.0
- * @category combinators
- */
-export const ensuring: {
-  <R2>(finalizer: Effect.Effect<void, never, R2>): <A, E, R>(self: Fx<A, E, R>) => Fx<A, E, R | R2>;
-
-  <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<void, never, R2>): Fx<A, E, R | R2>;
-} = dual(
-  2,
-  <A, E, R, R2>(self: Fx<A, E, R>, finalizer: Effect.Effect<void, never, R2>): Fx<A, E, R | R2> =>
-    make<A, E, R | R2>((sink) => self.run(sink).pipe(Effect.ensuring(finalizer))),
-);