@fncts/io 0.0.49 → 0.0.51

package/_src/Subject/RefSubject/Atomic.ts

@@ -0,0 +1,233 @@
+import type { Runtime } from "@fncts/io/IO/runtime";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
+import type { Scope } from "@fncts/io/Scope";
+
+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";
+import { HoldSubject } from "../Hold.js";
+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 | Scope>,
+    readonly scope: Scope.Closeable,
+  ) {
+    super();
+
+    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();
+    return this.scope.close(Exit.interrupt(fiberId)) > this.interruptFiber > this.subject.interrupt;
+  });
+
+  readonly subscribers = this.subject.subscribers;
+
+  run<R1>(sink: UnsafeSink<R1, E, A>): IO<Scope | R1, never, void> {
+    return this.subject.run(sink);
+  }
+
+  onFailure(cause: Cause<E>): IO<never, never, void> {
+    const exit = Exit.failCause(cause);
+    return IO.defer(() => {
+      if (this.futureRef.done(exit)) {
+        return this.sendEvent(exit);
+      } else {
+        return IO.unit;
+      }
+    });
+  }
+
+  onSuccess = this.set;
+
+  modify<C>(f: (a: A) => readonly [C, A], __tsplusTrace?: string): IO<never, E, C> {
+    return this.get.flatMap((a) => {
+      const [c, a1] = f(a);
+      return this.set(a1).as(c);
+    });
+  }
+
+  modifyIO<R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<R1, E1 | E, B> {
+    return this.get.flatMap(f).flatMap(([b, a]) => this.set(a).as(b));
+  }
+
+  match<EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    set: (_: C) => Either<EC, A>,
+    get: (_: A) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<never, never, EC, ED, C, D> {
+    return this.matchIO(setError, getError, set, get);
+  }
+
+  matchAll<EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    setGetError: (_: E) => EC,
+    set: (_: C) => (_: A) => Either<EC, A>,
+    get: (_: A) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<never, never, EC, ED, C, D> {
+    return this.matchAllIO(setError, getError, setGetError, set, get);
+  }
+
+  matchIO<RC, RD, EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    set: (_: C) => IO<RC, EC, A>,
+    get: (_: A) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RC, RD, EC, ED, C, D> {
+    return new PSynchronizedInternal(
+      this.semaphore,
+      this.get.matchIO((e) => IO.failNow(getError(e)), get),
+      (c) => set(c).flatMap((a) => this.set(a).mapError(setError)),
+    );
+  }
+
+  matchAllIO<RC, RD, EC, ED, C, D>(
+    setError: (_: E) => EC,
+    getError: (_: E) => ED,
+    setGetError: (_: E) => EC,
+    set: (_: C) => (_: A) => IO<RC, EC, A>,
+    get: (_: A) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronizedInternal<RC, RD, EC, ED, C, D> {
+    return new PSynchronizedInternal(
+      this.semaphore,
+      this.get.matchIO((e) => IO.failNow(getError(e)), get),
+      (c) =>
+        this.get.matchIO(
+          (e) => IO.failNow(setGetError(e)),
+          (b) => set(c)(b).flatMap((a) => this.set(a).mapError(setError)),
+        ),
+    );
+  }
+
+  matchIOSubject<RC, RD, EI, EC, ED, C, D>(
+    mapSetError: (_: E) => EC,
+    mapGetError: (_: E) => ED,
+    mapErrorInput: (_: EI) => E,
+    mapSetErrorInput: (_: EC) => E,
+    mapSet: (_: C) => IO<RC, EC, A>,
+    mapGet: (_: A) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PRefSubject<RC, RD, EI, ED, EC, C, D> {
+    return new Derived((f) =>
+      f({
+        ref: this,
+        mapSetError,
+        mapGetError,
+        mapErrorInput,
+        mapSetErrorInput,
+        mapSet,
+        mapGet,
+      }),
+    );
+  }
+
+  set(a: A, __tsplusTrace?: string): IO<never, never, void> {
+    const exit = Exit.succeed(a);
+    return IO.defer(() => {
+      if (this.futureRef.done(exit)) {
+        return this.sendEvent(exit);
+      } else {
+        return IO.unit;
+      }
+    });
+  }
+
+  get get(): IO<never, E, A> {
+    return this.getOrInit(false);
+  }
+
+  private sendEvent(exit: Exit<E, A>) {
+    return exit.match(
+      (cause) => this.subject.onFailure(cause).provideEnvironment(this.runtime.environment),
+      (value) => this.subject.onSuccess(value).provideEnvironment(this.runtime.environment),
+    );
+  }
+
+  private getOrInit(lock: boolean) {
+    return IO.defer(() => {
+      if (this.fiber === null && this.futureRef.current.get.isNothing()) {
+        return this.init(lock) > this.futureRef;
+      } else {
+        return this.futureRef;
+      }
+    });
+  }
+
+  private interruptFiber = IO.defer(() => {
+    if (this.fiber) {
+      return this.fiber.interrupt;
+    } else {
+      return IO.unit;
+    }
+  });
+
+  private init(lock: boolean) {
+    const maybeWithLock = lock ? this.semaphore.withPermits(1) : Function.identity;
+
+    const initialize = maybeWithLock(
+      this.initial.provideEnvironment(this.runtime.environment).onExit((exit) =>
+        IO(() => {
+          this.fiber = null;
+          this.futureRef.done(exit);
+        }),
+      ),
+    );
+
+    return initialize.forkIn(this.scope).flatMap((fiber) => IO((this.fiber = fiber)));
+  }
+}

package/_src/Subject/RefSubject/Derived.ts

@@ -0,0 +1,184 @@
+import type { Atomic } from "./Atomic.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { Either } from "@fncts/base/data/Either";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
+import type { PRef } from "@fncts/io/Ref";
+import type { Scope } from "@fncts/io/Scope";
+
+import { IO } from "@fncts/io/IO";
+import { Sink } from "@fncts/io/Push/Sink";
+import { type PSynchronized, PSynchronizedInternal } from "@fncts/io/Ref";
+
+import { PRefSubject } from "./RefSubject.js";
+
+export class Derived<EnvIn, EnvOut, ErrIn, ErrOut, ErrInRef, In, Out> extends PRefSubject<
+  EnvIn,
+  EnvOut,
+  ErrIn,
+  ErrOut,
+  ErrInRef,
+  In,
+  Out
+> {
+  constructor(
+    readonly use: <X>(
+      f: <R, E0, A0>(_: {
+        ref: Atomic<R, E0, A0>;
+        mapSetError: (_: E0) => ErrInRef;
+        mapGetError: (_: E0) => ErrOut;
+        mapErrorInput: (_: ErrIn) => E0;
+        mapSetErrorInput: (_: ErrInRef) => E0;
+        mapSet: (a: In) => IO<EnvIn, ErrInRef, A0>;
+        mapGet: (a: A0) => IO<EnvOut, ErrOut, Out>;
+      }) => X,
+    ) => X,
+  ) {
+    super();
+  }
+
+  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 }) =>
+      mapSet(value).matchCauseIO(
+        (cause) => ref.onFailure(cause.map(mapSetErrorInput)),
+        (a0) => ref.onSuccess(a0),
+      ),
+    );
+  }
+
+  onFailure(cause: Cause<ErrIn>): IO<EnvIn, never, void> {
+    return this.use(({ ref, mapErrorInput }) => ref.onFailure(cause.map(mapErrorInput)));
+  }
+
+  get get(): IO<EnvOut, ErrOut, Out> {
+    return this.use(({ ref, mapGetError, mapGet }) => ref.get.matchIO((e) => IO.failNow(mapGetError(e)), mapGet));
+  }
+
+  set(a: In, __tsplusTrace?: string): IO<EnvIn, ErrInRef, void> {
+    return this.use(({ ref, mapSet }) => mapSet(a).flatMap((a0) => ref.set(a0)));
+  }
+
+  modify<C>(f: (b: Out) => readonly [C, In], __tsplusTrace?: string): IO<EnvIn | EnvOut, ErrOut | ErrInRef, C> {
+    return this.modifyIO((out) => IO.succeedNow(f(out)));
+  }
+
+  modifyIO<R1, E1, C>(
+    f: (b: Out) => IO<R1, E1, readonly [C, In]>,
+    __tsplusTrace?: string,
+  ): IO<EnvIn | EnvOut | R1, ErrOut | ErrInRef | E1, C> {
+    return this.use(({ ref, mapGetError, mapSet, mapGet }) =>
+      ref.get.mapError(mapGetError).flatMap((a0) =>
+        mapGet(a0)
+          .flatMap(f)
+          .flatMap(([c, a]) =>
+            mapSet(a)
+              .flatMap((a0) => ref.set(a0))
+              .as(c),
+          ),
+      ),
+    );
+  }
+
+  match<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ca: (_: C) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PRef<EnvIn, EnvOut, EC, ED, C, D> {
+    return this.matchIO(ea, eb, ca, bd);
+  }
+
+  matchAll<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ec: (_: ErrOut) => EC,
+    ca: (_: C) => (_: Out) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+    __tsplusTrace?: string,
+  ): PRef<EnvIn | EnvOut, EnvOut, EC, ED, C, D> {
+    return this.matchAllIO(ea, eb, ec, ca, bd);
+  }
+
+  matchIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | RC, EnvOut | RD, EC, ED, C, D> {
+    return this.use(
+      ({ ref }) =>
+        new PSynchronizedInternal(
+          ref.semaphore,
+          this.get.matchIO((e) => IO.failNow(mapGetError(e)), mapGet),
+          (c) => mapSet(c).flatMap((a) => this.set(a).mapError(mapSetError)),
+        ),
+    );
+  }
+
+  matchAllIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSetGetError: (_: ErrOut) => EC,
+    mapSet: (_: C) => (_: Out) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | EnvOut | RC, EnvOut | RD, EC, ED, C, D> {
+    return this.use(
+      ({ ref }) =>
+        new PSynchronizedInternal(
+          ref.semaphore,
+          this.get.matchIO((e) => IO.failNow(mapGetError(e)), mapGet),
+          (c) =>
+            this.get.matchIO(
+              (e) => IO.failNow(mapSetGetError(e)),
+              (b) => mapSet(c)(b).flatMap((a) => this.set(a).mapError(mapSetError)),
+            ),
+        ),
+    );
+  }
+
+  matchIOSubject<RC, RD, EI, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapErrorInput: (_: EI) => ErrIn,
+    mapSetErrorInput: (_: EC) => ErrInRef,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PRefSubject<EnvIn | RC, EnvOut | RD, EI, ED, EC, C, D> {
+    return this.use(
+      (r) =>
+        new Derived<EnvIn | RC, EnvOut | RD, EI, ED, EC, C, D>((f) =>
+          f({
+            ref: r.ref,
+            mapSetError: (e0) => mapSetError(r.mapSetError(e0)),
+            mapGetError: (e0) => mapGetError(r.mapGetError(e0)),
+            mapErrorInput: (ei) => r.mapErrorInput(mapErrorInput(ei)),
+            mapSetErrorInput: (ec) => r.mapSetErrorInput(mapSetErrorInput(ec)),
+            mapSet: (c) => mapSet(c).flatMap((inp) => r.mapSet(inp).mapError(mapSetError)),
+            mapGet: (a0) => r.mapGet(a0).mapError(mapGetError).flatMap(mapGet),
+          }),
+        ),
+    );
+  }
+
+  run<R1>(sink: UnsafeSink<R1, ErrOut, Out>): IO<Scope | EnvOut | R1, never, void> {
+    return this.use(({ ref, mapGet, mapGetError }) =>
+      ref.run(
+        Sink.unsafeMake(
+          (a0) => mapGet(a0).matchCauseIO(sink.onFailure, sink.onSuccess),
+          (cause) => sink.onFailure(cause.map(mapGetError)),
+        ),
+      ),
+    );
+  }
+}

package/_src/Subject/RefSubject/RefSubject.ts

@@ -0,0 +1,100 @@
+import type {
+  MappableRef,
+  MappableSynchronized,
+  ModifiableRef,
+  ModifiableSynchronized,
+  PSynchronized,
+  ReadableRef,
+  WritableRef,
+} from "../../Ref.js";
+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
+    PRef<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    PSynchronized<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    ReadableRef<EnvOut, ErrOut, Out>,
+    WritableRef<EnvIn, ErrInRef, In>,
+    ModifiableRef<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    MappableRef<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    ModifiableSynchronized<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>,
+    MappableSynchronized<EnvIn, EnvOut, ErrInRef, ErrOut, In, Out>
+{
+  readonly [SynchronizedTypeId]: SynchronizedTypeId = SynchronizedTypeId;
+  readonly [RefTypeId]: RefTypeId                   = RefTypeId;
+  declare [RefVariance]: {
+    readonly _RA: (_: never) => EnvIn;
+    readonly _RB: (_: never) => EnvOut;
+    readonly _EA: (_: never) => ErrInRef;
+    readonly _EB: (_: never) => ErrOut;
+    readonly _A: (_: In) => void;
+    readonly _B: (_: never) => Out;
+  };
+
+  abstract get: IO<EnvOut, ErrOut, Out>;
+
+  abstract set(a: In, __tsplusTrace?: string): IO<EnvIn, ErrInRef, void>;
+
+  abstract modify<C>(f: (b: Out) => readonly [C, In], __tsplusTrace?: string): IO<EnvIn | EnvOut, ErrOut | ErrInRef, C>;
+
+  abstract modifyIO<R1, E1, C>(
+    f: (b: Out) => IO<R1, E1, readonly [C, In]>,
+    __tsplusTrace?: string,
+  ): IO<EnvIn | EnvOut | R1, ErrOut | ErrInRef | E1, C>;
+
+  abstract match<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ca: (_: C) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+  ): PRef<EnvIn, EnvOut, EC, ED, C, D>;
+
+  abstract matchAll<EC, ED, C, D>(
+    ea: (_: ErrInRef) => EC,
+    eb: (_: ErrOut) => ED,
+    ec: (_: ErrOut) => EC,
+    ca: (_: C) => (_: Out) => Either<EC, In>,
+    bd: (_: Out) => Either<ED, D>,
+  ): PRef<EnvIn | EnvOut, EnvOut, EC, ED, C, D>;
+
+  abstract matchIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | RC, EnvOut | RD, EC, ED, C, D>;
+
+  abstract matchAllIO<RC, RD, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapSetGetError: (_: ErrOut) => EC,
+    mapSet: (_: C) => (_: Out) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PSynchronized<EnvIn | EnvOut | RC, EnvOut | RD, EC, ED, C, D>;
+
+  abstract matchIOSubject<RC, RD, EI, EC, ED, C, D>(
+    mapSetError: (_: ErrInRef) => EC,
+    mapGetError: (_: ErrOut) => ED,
+    mapErrorInput: (_: EI) => ErrIn,
+    mapSetErrorInput: (_: EC) => ErrInRef,
+    mapSet: (_: C) => IO<RC, EC, In>,
+    mapGet: (_: Out) => IO<RD, ED, D>,
+    __tsplusTrace?: string,
+  ): PRefSubject<EnvIn | RC, EnvOut | RD, EI, ED, EC, C, D>;
+}

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/definition.ts

@@ -1,4 +1,8 @@
-import type { Push, Sink } from "../Push.js";
+import type { UnsafeSink } from "../Push/Sink.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { IO } from "@fncts/io/IO";
+
+import { Push, PushTypeId } from "../Push.js";
 
 export const SubjectTypeId = Symbol.for("fncts.io.Push.Subject");
 export type SubjectTypeId = typeof SubjectTypeId;
@@ -6,10 +10,24 @@ export type SubjectTypeId = typeof SubjectTypeId;
 /**
  * @tsplus type fncts.io.Push.Subject
  */
-export interface Subject<R, E, A> extends Push<R, E, A>, Sink<R, E, A> {
-  readonly [SubjectTypeId]: SubjectTypeId;
+export abstract class PSubject<out EnvIn, out EnvOut, in ErrIn, out ErrOut, in In, Out>
+  extends Push<EnvOut | Scope, ErrOut, Out>
+  implements Push<EnvOut | Scope, ErrOut, Out>, UnsafeSink<EnvIn, ErrIn, In>
+{
+  readonly _pushOpCode                    = null;
+  readonly [PushTypeId]: PushTypeId       = PushTypeId;
+  readonly [SubjectTypeId]: SubjectTypeId = SubjectTypeId;
+
+  abstract onSuccess(value: In): IO<EnvIn, never, void>;
+  abstract onFailure(cause: Cause<ErrIn>): IO<EnvIn, never, void>;
+
+  abstract interrupt: URIO<EnvIn, void>;
+
+  abstract subscribers: number;
 }
 
+export type Subject<R, E, A> = PSubject<R, R, E, E, A, A>;
+
 /**
  * @tsplus type fncts.io.Push.SubjectOps
  */

package/_src/Subject.ts

@@ -1,5 +1,8 @@
 // codegen:start { preset: barrel, include: ./Subject/*.ts }
-export * from "./Subject/api.js";
-export * from "./Subject/Atomic.js";
-export * from "./Subject/definition.js";
+export * from "./Subject/api.js"
+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

package/_src/SubscriptionRef.ts

@@ -7,7 +7,7 @@ export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
 export class SubscriptionRefInternal<A> extends PSynchronizedInternal<never, never, never, never, A, A> {
   readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId = SubscriptionRefTypeId;
   constructor(
-    readonly semaphore: Semaphore,
+    semaphore: Semaphore,
     readonly hub: Hub<A>,
     readonly ref: Ref<A>,
   ) {

package/_src/Supervisor/constructors.ts

@@ -17,11 +17,9 @@ export function unsafeTrack(weak: boolean): Supervisor<Conc<Fiber.Runtime<any, a
       _parent: Maybe<Fiber.Runtime<E, A>>,
       fiber: Fiber.Runtime<E, A>,
     ) {
-      // @ts-expect-error
       set.add(fiber);
     }
     unsafeOnEnd<E, A>(_value: Exit<E, A>, fiber: Fiber.Runtime<E, A>) {
-      // @ts-expect-error
       set.delete(fiber);
     }
   })();

package/_src/Supervisor/definition.ts

@@ -87,13 +87,14 @@ export class ProxySupervisor<A> extends Supervisor<A> {
 
 export class Zip<A, B> extends Supervisor<readonly [A, B]> {
   readonly _tag = SupervisorTag.Zip;
+  readonly value: UIO<readonly [A, B]>;
   constructor(
     readonly first: Supervisor<A>,
     readonly second: Supervisor<B>,
   ) {
     super();
+    this.value = this.first.value.zip(this.second.value);
   }
-  value = this.first.value.zip(this.second.value);
   unsafeOnStart<R, E, A>(
     environment: Environment<R>,
     effect: IO<R, E, A>,

package/_src/TReentrantLock/api.ts

@@ -1,4 +1,4 @@
-import type { Lock, LockState } from "./definition.js";
+import type { LockState } from "./definition.js";
 
 import { RetryException } from "../STM.js";
 import { ReadLock, TReentrantLock } from "./definition.js";

package/_src/global.ts

@@ -135,6 +135,14 @@ import { STM, USTM } from "@fncts/io/STM/definition";
  * @tsplus global
  */
 import { Stream } from "@fncts/io/Stream/definition";
+/**
+ * @tsplus global
+ */
+import { Subject } from "@fncts/io/Subject";
+/**
+ * @tsplus global
+ */
+import { PRefSubject, RefSubject } from "@fncts/io/Subject/RefSubject/RefSubject";
 /**
  * @tsplus global
  */