@fncts/io 0.0.50 → 0.0.51

package/_src/Push/api.ts

@@ -2,14 +2,25 @@ import type { MergeStrategy } from "./MergeStrategy.js";
 import type { UnsafeSink } from "@fncts/io/Push/Sink";
 
 import { IO, IOTag } from "@fncts/io/IO";
-import { FlattenStrategy, UnboundedStrategy } from "@fncts/io/Push";
-import { Push, PushPrimitive, PushTag } from "@fncts/io/Push";
+import { Push, PushPrimitive, PushTag } from "@fncts/io/Push/definition";
+import { FlattenStrategy, UnboundedStrategy } from "@fncts/io/Push/FlattenStrategy";
 import { SyncProducer } from "@fncts/io/Push/Producer/SyncProducer";
 import { Sink } from "@fncts/io/Push/Sink";
 import { Scope } from "@fncts/io/Scope";
 
 import { FromIO, FromScheduled, type IOProducer, Scheduled } from "./Producer/IOProducer.js";
 
+/**
+ * @tsplus static fncts.io.PushOps bracketExit
+ */
+export function bracketExit<R, E, A, R1, E1, B, R2, E2, C>(
+  acquire: IO<R, E, A>,
+  use: (a: A) => Push<R1, E1, B>,
+  release: (a: A, exit: Exit<unknown, unknown>) => IO<R2, E2, C>,
+): Push<R | R1 | R2, E | E1 | E2, B> {
+  return new BracketExit(acquire, use, release);
+}
+
 class BracketExit<R, E, A, R1, E1, B, R2, E2, C> extends Push<R | R1 | R2, E | E1 | E2, B> {
   constructor(
     readonly acquire: IO<R, E, A>,
@@ -29,14 +40,10 @@ class BracketExit<R, E, A, R1, E1, B, R2, E2, C> extends Push<R | R1 | R2, E | E
 }
 
 /**
- * @tsplus static fncts.io.PushOps bracketExit
+ * @tsplus static fncts.io.PushOps defer
  */
-export function bracketExit<R, E, A, R1, E1, B, R2, E2, C>(
-  acquire: IO<R, E, A>,
-  use: (a: A) => Push<R1, E1, B>,
-  release: (a: A, exit: Exit<unknown, unknown>) => IO<R2, E2, C>,
-): Push<R | R1 | R2, E | E1 | E2, B> {
-  return new BracketExit(acquire, use, release);
+export function defer<R, E, A>(self: Lazy<Push<R, E, A>>): Push<R, E, A> {
+  return new Defer(self);
 }
 
 class CombineLatest<R, E, A> extends Push<R | Scope, E, ReadonlyArray<A>> {
@@ -88,11 +95,11 @@ class CombineLatest<R, E, A> extends Push<R | Scope, E, ReadonlyArray<A>> {
 export function combineLatest<A extends ReadonlyArray<Push<any, any, any>>>(
   streams: [...A],
 ): Push<Push.EnvironmentOf<A[number]> | Scope, Push.ErrorOf<A[number]>, { [K in keyof A]: Push.ValueOf<A[K]> }>;
-
 export function combineLatest<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R | Scope, E, ReadonlyArray<A>>;
 export function combineLatest<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R | Scope, E, ReadonlyArray<A>> {
   return new CombineLatest(streams);
 }
+
 class ContramapEnvironment<R, E, A, R1> extends Push<R1, E, A> {
   constructor(
     readonly self: Push<R, E, A>,
@@ -122,13 +129,6 @@ class Defer<R, E, A> extends Push<R, E, A> {
   }
 }
 
-/**
- * @tsplus static fncts.io.PushOps defer
- */
-export function defer<R, E, A>(self: Lazy<Push<R, E, A>>): Push<R, E, A> {
-  return new Defer(self);
-}
-
 /**
  * @tsplus static fncts.io.PushOps failCause
  */

package/_src/Queue/api/dimapIO.ts

@@ -27,11 +27,17 @@ class DimapIO<RA, RB, EA, EB, A, B, RC, EC, C, RD, ED, D> extends QueueInternal<
     super();
   }
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -49,13 +55,21 @@ class DimapIO<RA, RB, EA, EB, A, B, RC, EC, C, RD, ED, D> extends QueueInternal<
     return IO.foreach(cs, this.f).flatMap((as) => this.queue.offerAll(as));
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
-  take: IO<RD | RB, ED | EB, D> = this.queue.take.flatMap(this.g);
+  get take(): IO<RD | RB, ED | EB, D> {
+    return this.queue.take.flatMap(this.g);
+  }
 
-  takeAll: IO<RD | RB, ED | EB, Conc<D>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.g));
+  get takeAll(): IO<RD | RB, ED | EB, Conc<D>> {
+    return this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.g));
+  }
 
   takeUpTo(n: number): IO<RD | RB, ED | EB, Conc<D>> {
     return this.queue.takeUpTo(n).flatMap((bs) => IO.foreach(bs, this.g));
@@ -154,11 +168,17 @@ class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<R
     readonly f: (c: C) => IO<RC, EC, A>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -176,9 +196,13 @@ class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<R
     return IO.foreach(cs, this.f).flatMap((as) => this.queue.offerAll(as));
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 }
 
 /**
@@ -209,15 +233,25 @@ class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB
     readonly f: (b: B) => IO<RC, EC, C>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -227,9 +261,13 @@ class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB
     throw new Error("Cannot unsafely offer to an effectful Queue");
   }
 
-  take: IO<RB | RC, EB | EC, C> = this.queue.take.flatMap(this.f);
+  get take(): IO<RB | RC, EB | EC, C> {
+    return this.queue.take.flatMap(this.f);
+  }
 
-  takeAll: IO<RB | RC, EB | EC, Conc<C>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.f));
+  get takeAll(): IO<RB | RC, EB | EC, Conc<C>> {
+    return this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.f));
+  }
 
   takeUpTo(n: number): IO<RB | RC, EB | EC, Conc<C>> {
     return this.queue.takeUpTo(n).flatMap((bs) => IO.foreach(bs, this.f));

package/_src/Queue/api/filterInputIO.ts

@@ -10,11 +10,17 @@ class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInt
     super();
   }
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -39,13 +45,21 @@ class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInt
     });
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
-  take: IO<RB, EB, B> = this.queue.take;
+  get take(): IO<RB, EB, B> {
+    return this.queue.take;
+  }
 
-  takeAll: IO<RB, EB, Conc<B>> = this.queue.takeAll;
+  get takeAll(): IO<RB, EB, Conc<B>> {
+    return this.queue.takeAll;
+  }
 
   takeUpTo(max: number): IO<RB, EB, Conc<B>> {
     return this.queue.takeUpTo(max);
@@ -94,11 +108,17 @@ class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
     readonly f: (_: A1) => IO<R2, E2, boolean>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -123,9 +143,13 @@ class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
     });
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 }
 
 /**

package/_src/Queue/api/filterOutputIO.ts

@@ -10,11 +10,17 @@ class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, R
     super();
   }
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -32,15 +38,21 @@ class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, R
     return this.queue.offerAll(as);
   }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
-  take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
-    this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
-  );
+  get take(): IO<RB | RB1, EB1 | EB, B> {
+    return this.queue.take.flatMap((b) => this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)));
+  }
 
-  takeAll: IO<RB | RB1, EB | EB1, Conc<B>> = this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+  get takeAll(): IO<RB | RB1, EB | EB1, Conc<B>> {
+    return this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+  }
 
   loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>> {
     return this.queue.takeUpTo(max).flatMap((bs) => {
@@ -102,15 +114,25 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
     readonly f: (b: B) => IO<RB1, EB1, boolean>,
   ) {}
 
-  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+  get awaitShutdown(): UIO<void> {
+    return this.queue.awaitShutdown;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = this.queue.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.queue.isShutdown;
+  }
 
-  shutdown: UIO<void> = this.queue.shutdown;
+  get shutdown(): UIO<void> {
+    return this.queue.shutdown;
+  }
 
-  size: UIO<number> = this.queue.size;
+  get size(): UIO<number> {
+    return this.queue.size;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.queue.unsafeSize;
@@ -120,11 +142,13 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
     throw new Error("Cannot unsafely offer to an effectful Queue");
   }
 
-  take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
-    this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
-  );
+  get take(): IO<RB | RB1, EB1 | EB, B> {
+    return this.queue.take.flatMap((b) => this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)));
+  }
 
-  takeAll: IO<RB | RB1, EB | EB1, Conc<B>> = this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+  get takeAll(): IO<RB | RB1, EB | EB1, Conc<B>> {
+    return this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+  }
 
   loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>> {
     return this.queue.takeUpTo(max).flatMap((bs) => {

package/_src/Queue/api/zipWithIO.ts

@@ -17,11 +17,17 @@ class ZipWithIO<RA, RB, EA, EB, A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3,
     super();
   }
 
-  awaitShutdown: UIO<void> = this.fa.awaitShutdown.flatMap(() => this.fb.awaitShutdown);
+  get awaitShutdown(): UIO<void> {
+    return this.fa.awaitShutdown.flatMap(() => this.fb.awaitShutdown);
+  }
 
-  capacity: number = Math.min(this.fa.capacity, this.fb.capacity);
+  get capacity(): number {
+    return Math.min(this.fa.capacity, this.fb.capacity);
+  }
 
-  isShutdown: UIO<boolean> = this.fa.isShutdown;
+  get isShutdown(): UIO<boolean> {
+    return this.fa.isShutdown;
+  }
 
   get unsafeSize(): Maybe<number> {
     return this.fa.unsafeSize.zipWith(this.fb.unsafeSize, (a, b) => Math.max(a, b));
@@ -39,17 +45,23 @@ class ZipWithIO<RA, RB, EA, EB, A, B, RA1, RB1, EA1, EB1, A1 extends A, B1, R3,
     return this.fa.offerAll(as).zipWithConcurrent(this.fb.offerAll(as), (x, y) => x && y);
   }
 
-  shutdown: UIO<void> = this.fa.shutdown.zipWithConcurrent(this.fb.shutdown, () => undefined);
+  get shutdown(): UIO<void> {
+    return this.fa.shutdown.zipWithConcurrent(this.fb.shutdown, () => undefined);
+  }
 
-  size: UIO<number> = this.fa.size.zipWithConcurrent(this.fb.size, (x, y) => Math.max(x, y));
+  get size(): UIO<number> {
+    return this.fa.size.zipWithConcurrent(this.fb.size, (x, y) => Math.max(x, y));
+  }
 
-  take: IO<RB | RB1 | R3, E3 | EB | EB1, C> = this.fa.take
-    .zipConcurrent(this.fb.take)
-    .flatMap(([b, c]) => this.f(b, c));
+  get take(): IO<RB | RB1 | R3, E3 | EB | EB1, C> {
+    return this.fa.take.zipConcurrent(this.fb.take).flatMap(([b, c]) => this.f(b, c));
+  }
 
-  takeAll: IO<RB | RB1 | R3, E3 | EB | EB1, Conc<C>> = this.fa.takeAll
-    .zipConcurrent(this.fb.takeAll)
-    .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
+  get takeAll(): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<C>> {
+    return this.fa.takeAll
+      .zipConcurrent(this.fb.takeAll)
+      .flatMap(([bs, cs]) => IO.foreach(bs.zip(cs), ([b, c]) => this.f(b, c)));
+  }
 
   takeUpTo(max: number): IO<RB | RB1 | R3, E3 | EB | EB1, Conc<C>> {
     return this.fa

package/_src/Queue/internal.ts

@@ -16,11 +16,17 @@ class UnsafeQueue<A> extends QueueInternal<never, never, never, never, A, A> {
     super();
   }
 
-  awaitShutdown: UIO<void> = this.shutdownHook.await;
+  get awaitShutdown(): UIO<void> {
+    return this.shutdownHook.await;
+  }
 
-  capacity: number = this.queue.capacity;
+  get capacity(): number {
+    return this.queue.capacity;
+  }
 
-  isShutdown: UIO<boolean> = IO.succeed(this.shutdownFlag.get);
+  get isShutdown(): UIO<boolean> {
+    return IO.succeed(this.shutdownFlag.get);
+  }
 
   get unsafeSize(): Maybe<number> {
     if (this.shutdownFlag.get) {

package/_src/Schedule/api.ts

@@ -9,7 +9,7 @@ export function make<State, Env, In, Out>(
   __tsplusTrace?: string,
 ): Schedule.WithState<State, Env, In, Out> {
   return new (class extends Schedule<Env, In, Out> {
-    readonly _State!: State;
+    declare readonly _State: State;
     initial = initial;
     step = step;
   })();

package/_src/ScopedRef/api.ts

@@ -20,7 +20,9 @@ class Synch<A> extends ScopedRef<A> {
   constructor(readonly ref: Ref.Synchronized<readonly [Scope.Closeable, A]>) {
     super();
   }
-  close: UIO<void> = this.ref.get.flatMap(([scope, _]) => scope.close(Exit.unit));
+  get close(): UIO<void> {
+    return this.ref.get.flatMap(([scope, _]) => scope.close(Exit.unit));
+  }
   set<R, E>(acquire: IO<R, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void> {
     return this.ref.modifyIO(([oldScope, a]) =>
       IO.uninterruptibleMask((restore) =>
@@ -39,5 +41,7 @@ class Synch<A> extends ScopedRef<A> {
       ),
     ).flatten;
   }
-  get: UIO<A> = this.ref.get.map(([_, a]) => a);
+  get get(): UIO<A> {
+    return this.ref.get.map(([_, a]) => a);
+  }
 }

package/_src/Semaphore/definition.ts

@@ -7,9 +7,11 @@ import { Reservation } from "@fncts/io/Semaphore/Reservation";
  * @tsplus companion fncts.io.SemaphoreOps
  */
 export class Semaphore {
-  constructor(readonly permits: number) {}
+  readonly ref: Ref<Either<ImmutableQueue<[Future<never, void>, number]>, number>>;
 
-  ref = Ref.unsafeMake<Either<ImmutableQueue<[Future<never, void>, number]>, number>>(Either.right(this.permits));
+  constructor(readonly permits: number) {
+    this.ref = Ref.unsafeMake(Either.right(this.permits));
+  }
 
   available(__tsplusTrace?: string): UIO<number> {
     return this.ref.get.map((_) =>

package/_src/Stream/api.ts

@@ -1367,9 +1367,7 @@ export function failNow<E>(error: E, __tsplusTrace?: string): Stream<never, E, n
  * @tsplus pipeable fncts.io.Stream filter
  */
 export function filter<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
-
 export function filter<A>(predicate: Predicate<A>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, A>;
-
 export function filter<A>(predicate: Predicate<A>, __tsplusTrace?: string) {
   return <R, E>(fa: Stream<R, E, A>): Stream<R, E, A> => {
     return fa.mapChunks((chunk) => chunk.filter(predicate));

package/_src/Subject/RefSubject/Atomic.ts

@@ -2,7 +2,9 @@ import type { Runtime } from "@fncts/io/IO/runtime";
 import type { UnsafeSink } from "@fncts/io/Push/Sink";
 import type { Scope } from "@fncts/io/Scope";
 
-import { IO } from "@fncts/io/IO";
+import { EitherTag } from "@fncts/base/data/Either";
+import { ExitTag } from "@fncts/base/data/Exit";
+import { IO, IOTag } from "@fncts/io/IO";
 import { PSynchronizedInternal } from "@fncts/io/Ref/Synchronized/definition";
 
 import { FutureRef } from "../DeferredRef.js";
@@ -11,19 +13,57 @@ import { Derived } from "./Derived.js";
 import { PRefSubject } from "./RefSubject.js";
 
 export class Atomic<R, E, A> extends PRefSubject<never, never, E, E, E, A, A> {
+  private futureRef: FutureRef<E, A>;
+
+  private subject                   = new HoldSubject<E, A>();
+  private fiber: Fiber<E, A> | null = null;
+
+  readonly semaphore = Semaphore.unsafeMake(1);
+
   constructor(
     readonly fiberId: FiberId,
     readonly initial: IO<R, E, A>,
-    readonly runtime: Runtime<R>,
+    readonly runtime: Runtime<R | Scope>,
     readonly scope: Scope.Closeable,
   ) {
     super();
-  }
 
-  readonly semaphore                = Semaphore.unsafeMake(1);
-  private subject                   = new HoldSubject<E, A>();
-  private futureRef                 = new FutureRef(this.fiberId, this.subject.value);
-  private fiber: Fiber<E, A> | null = null;
+    this.futureRef = new FutureRef(this.fiberId, this.subject.value);
+
+    const onSuccess = (a: A) => this.futureRef.done(Exit.succeed(a));
+    const onCause   = (cause: Cause<E>) => this.futureRef.done(Exit.failCause(cause));
+    const onError   = (e: E) => onCause(Cause.fail(e));
+    const io        = IO.concrete(initial);
+
+    switch (io._ioOpCode) {
+      case IOTag.SucceedNow:
+        onSuccess(io.i0);
+        break;
+      case null: {
+        switch (io._tag) {
+          case MaybeTag.Just:
+            onSuccess(io.value);
+            break;
+          case MaybeTag.Nothing:
+            onError(new NoSuchElementError() as E);
+            break;
+          case EitherTag.Right:
+            onSuccess(io.right);
+            break;
+          case EitherTag.Left:
+            onError(io.left);
+            break;
+          case ExitTag.Success:
+            onSuccess(io.value);
+            break;
+          case ExitTag.Failure:
+            onCause(io.cause);
+            break;
+        }
+        break;
+      }
+    }
+  }
 
   readonly interrupt = IO.fiberIdWith((fiberId) => {
     this.futureRef.reset();

package/_src/Subject/RefSubject/Derived.ts

@@ -36,8 +36,13 @@ export class Derived<EnvIn, EnvOut, ErrIn, ErrOut, ErrInRef, In, Out> extends PR
     super();
   }
 
-  subscribers = this.use(({ ref }) => ref.subscribers);
-  interrupt   = this.use(({ ref }) => ref.interrupt);
+  get subscribers() {
+    return this.use(({ ref }) => ref.subscribers);
+  }
+
+  get interrupt() {
+    return this.use(({ ref }) => ref.interrupt);
+  }
 
   onSuccess(value: In): IO<EnvIn, never, void> {
     return this.use(({ ref, mapSetErrorInput, mapSet }) =>

package/_src/Subject/RefSubject/RefSubject.ts

@@ -12,6 +12,16 @@ import type { IO } from "@fncts/io/IO";
 import { RefTypeId, RefVariance, SynchronizedTypeId } from "../../Ref.js";
 import { PSubject } from "../definition.js";
 
+/**
+ * @tsplus type fncts.io.RefSubject.RefSubject
+ * @tsplus companion fncts.io.RefSubject.RefSubjectOps
+ */
+export interface RefSubject<R, E, A> extends PRefSubject<R, R, E, E, E, A, A> {}
+
+/**
+ * @tsplus type fncts.io.RefSubject.PRefSubject
+ * @tsplus companion fncts.io.RefSubject.PRefSubjectOps
+ */
 export abstract class PRefSubject<EnvIn, EnvOut, ErrIn, ErrOut, ErrInRef, In, Out>
   extends PSubject<EnvIn, EnvOut, ErrIn, ErrOut, In, Out>
   implements

package/_src/Subject/RefSubject/constructors.ts

@@ -0,0 +1,27 @@
+import type { RefSubject } from "@fncts/io/Subject/RefSubject/RefSubject";
+
+import { Atomic } from "@fncts/io/Subject/RefSubject/Atomic";
+
+export interface RefSubjectOptions<A> {
+  executionStrategy?: ExecutionStrategy;
+  eq?: Eq<A>;
+}
+
+/**
+ * @tsplus static fncts.io.RefSubject.PRefSubjectOps fromIO
+ * @tsplus static fncts.io.RefSubject.RefSubjectOps fromIO
+ */
+export function fromIO<R, E, A>(
+  initial: IO<R, E, A>,
+  options?: RefSubjectOptions<A>,
+): IO<Scope | R, never, RefSubject<never, E, A>> {
+  return Do((Δ) => {
+    const runtime           = Δ(IO.runtime<R | Scope>());
+    const executionStrategy = options?.executionStrategy ?? ExecutionStrategy.concurrent;
+    const scope             = Δ(runtime.environment.get(Scope.Tag).forkWith(executionStrategy));
+    const fiberId           = Δ(IO.fiberId);
+    const refSubject        = new Atomic(fiberId, initial, runtime, scope);
+    Δ(scope.addFinalizer(refSubject.interrupt.provideEnvironment(runtime.environment)));
+    return refSubject;
+  });
+}

package/_src/Subject/RefSubject.ts

@@ -0,0 +1,7 @@
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: type-barrel, include: ./RefSubject/*.ts }
+export type {} from "./RefSubject/constructors.js";
+export type {} from "./RefSubject/RefSubject.js";
+export type {} from "./RefSubject/Derived.js";
+export type {} from "./RefSubject/Atomic.js";
+// codegen:end

package/_src/Subject.ts

@@ -4,4 +4,5 @@ export * from "./Subject/Atomic.js"
 export * from "./Subject/DeferredRef.js"
 export * from "./Subject/definition.js"
 export * from "./Subject/Hold.js"
+export * from "./Subject/RefSubject.js"
 // codegen:end