@fncts/io 0.0.21 → 0.0.23

package/Stream/api.d.ts

@@ -10,16 +10,17 @@ import { Fiber } from "@fncts/io/Fiber/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Dequeue, Enqueue } from "@fncts/io/Queue/definition";
 import { Future } from "@fncts/io/Future";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
 import { Duration } from "@fncts/base/data/Duration/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Layer } from "@fncts/io/Layer";
+import type { PHub } from "../Hub.js";
 import type { Canceler } from "../IO.js";
+import type { PDequeue, PEnqueue, PQueue } from "../Queue.js";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 import { Hub } from "../Hub.js";
 import { Queue } from "../Queue.js";
@@ -71,18 +72,18 @@ export declare function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(sink: S
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from this stream.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus pipeable fncts.io.Stream apFirst
+ * @tsplus pipeable fncts.io.Stream zipLeft
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apFirst<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from the other stream.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus pipeable fncts.io.Stream apSecond
+ * @tsplus pipeable fncts.io.Stream zipRight
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apSecond<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1>;
+export declare function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1>;
 /**
  * Maps the success values of this stream to the specified constant value.
  * @tsplus pipeable fncts.io.Stream as
@@ -158,7 +159,7 @@ export declare function broadcastDynamic(maximumLag: number, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.Stream broadcastedQueues
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueues(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<import("../Queue.js").Dequeue<Take<E, A>>>>;
+export declare function broadcastedQueues(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<Take<E, A>>>>;
 /**
  * Converts the stream to a managed dynamic amount of queues. Every chunk will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
@@ -167,7 +168,7 @@ export declare function broadcastedQueues(n: number, maximumLag: number, __tsplu
  * @tsplus pipeable fncts.io.Stream broadcastedQueuesDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueuesDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").IO<import("../Scope.js").Scope, never, import("../Queue.js").Dequeue<Take<E, A>>>>;
+export declare function broadcastedQueuesDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").IO<import("../Scope.js").Scope, never, Queue.Dequeue<Take<E, A>>>>;
 /**
  * Allows a faster producer to progress independently of a slower consumer by buffering
  * up to `capacity` elements in a queue.
@@ -322,7 +323,7 @@ export declare function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplu
  * @tsplus pipeable fncts.io.Stream distributedWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWith<A>(n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<import("../Queue.js").Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>>;
+export declare function distributedWith<A>(n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>>;
 /**
  * More powerful version of `ZStream#distributedWith`. This returns a function that will produce
  * new queues and corresponding indices.
@@ -333,7 +334,7 @@ export declare function distributedWith<A>(n: number, maximumLag: number, decide
  * @tsplus pipeable fncts.io.Stream distributedWithDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWithDynamic<E, A>(maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").UIO<readonly [symbol, import("../Queue.js").Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>]>>;
+export declare function distributedWithDynamic<E, A>(maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").UIO<readonly [symbol, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>]>>;
 /**
  * Converts this stream to a stream that executes its effects but emits no
  * elements. Useful for sequencing effects using streams.
@@ -561,12 +562,12 @@ export declare function fromPull<R, E, A>(scopedPull: IO<R, never, IO<R, Maybe<E
  * @tsplus static fncts.io.StreamOps fromQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueue<O>(queue: Dequeue<O>, maxChunkSize?: number, __tsplusTrace?: string): Stream<never, never, O>;
+export declare function fromQueue<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, maxChunkSize?: number, __tsplusTrace?: string): Stream<RB, EB, B>;
 /**
  * @tsplus static fncts.io.StreamOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueueWithShutdown<R, E, A>(queue: Dequeue<A>, maxChunkSize?: number, __tsplusTrace?: string): Stream<never, never, A>;
+export declare function fromQueueWithShutdown<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, maxChunkSize?: number, __tsplusTrace?: string): Stream<RB, EB, B>;
 /**
  * @tsplus static fncts.io.StreamOps fromHub
  * @tsplus location "@fncts/io/Stream/api"
@@ -894,21 +895,21 @@ export declare function runForeachScoped<A, R2, E2>(f: (a: A) => IO<R2, E2, any>
  * @tsplus pipeable fncts.io.Stream runIntoElementsScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoElementsScoped<E, A, E1>(queue: Queue<Exit<Maybe<E | E1>, A>>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, E | E1, void>;
+export declare function runIntoElementsScoped_<E, A, R1, E1>(queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R1 | R, E | E1, void>;
 /**
  * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoQueueScoped<E1, A>(queue: Enqueue<Take<E1, A>>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, E1 | E, void>;
+export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus pipeable fncts.io.Stream runIntoHubScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoHubScoped<E1, A>(hub: Hub<Take<E1, A>>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, E1 | E, void>;
+export declare function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  * @tsplus pipeable fncts.io.Stream runScoped
@@ -1015,22 +1016,22 @@ export declare function toPull<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?:
  * @tsplus pipeable fncts.io.Stream toQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueue(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<Take<E, A>>>;
+export declare function toQueue(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueDropping
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueDropping(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<Take<E, A>>>;
+export declare function toQueueDropping(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueOfElements
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueOfElements(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>;
+export declare function toQueueOfElements(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueSliding
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueSliding(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<Take<E, A>>>;
+export declare function toQueueSliding(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * Converts the stream into an unbounded managed queue. After the managed queue
  * is used, the queue will never again produce values and should be discarded.

package/Stream/definition.d.ts

@@ -1,6 +1,7 @@
 import { Channel } from "@fncts/io/Channel";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import type { _A, _E, _R } from "@fncts/base/types";
+export declare const StreamVariance: unique symbol;
+export type StreamVariance = typeof StreamVariance;
 export declare const StreamTypeId: unique symbol;
 export type StreamTypeId = typeof StreamTypeId;
 /**
@@ -26,13 +27,33 @@ export type StreamTypeId = typeof StreamTypeId;
 export declare class Stream<R, E, A> {
     readonly channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>;
     readonly [StreamTypeId]: StreamTypeId;
-    _R: () => R;
-    _E: () => E;
-    _A: () => A;
+    [StreamVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
     constructor(channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>);
 }
 /**
  * @tsplus unify fncts.io.Stream
  */
-export declare function unifyStream<X extends Stream<any, any, any>>(_: X): Stream<_R<X>, _E<X>, _A<X>>;
+export declare function unifyStream<X extends Stream<any, any, any>>(_: X): Stream<[
+    X
+] extends [{
+    [StreamVariance]: {
+        _R: (_: never) => infer R;
+    };
+}] ? R : never, [
+    X
+] extends [{
+    [StreamVariance]: {
+        _E: (_: never) => infer E;
+    };
+}] ? E : never, [
+    X
+] extends [{
+    [StreamVariance]: {
+        _A: (_: never) => infer A;
+    };
+}] ? A : never>;
 export declare const DEFAULT_CHUNK_SIZE = 4096;

package/Stream/internal/Handoff.d.ts

@@ -1,4 +1,4 @@
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Future } from "@fncts/io/Future";
 import { UIO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
@@ -13,20 +13,22 @@ export declare class Handoff<A> {
     readonly ref: Ref<State<A>>;
     constructor(ref: Ref<State<A>>);
 }
+declare const enum HandoffStateTag {
+    Empty = 0,
+    Full = 1
+}
 export declare const StateTypeId: unique symbol;
-export declare const EmptyTypeId: unique symbol;
 export declare class Empty {
     readonly notifyConsumer: Future<never, void>;
-    readonly _typeId: typeof StateTypeId;
-    readonly _tag: typeof EmptyTypeId;
+    readonly [StateTypeId]: typeof StateTypeId;
+    readonly _tag = HandoffStateTag.Empty;
     constructor(notifyConsumer: Future<never, void>);
 }
-export declare const FullTypeId: unique symbol;
 export declare class Full<A> {
     readonly a: A;
     readonly notifyProducer: Future<never, void>;
-    readonly _typeId: typeof StateTypeId;
-    readonly _tag: typeof FullTypeId;
+    readonly [StateTypeId]: typeof StateTypeId;
+    readonly _tag = HandoffStateTag.Full;
     constructor(a: A, notifyProducer: Future<never, void>);
 }
 export type State<A> = Empty | Full<A>;
@@ -51,28 +53,31 @@ export declare function take<A>(handoff: Handoff<A>): UIO<A>;
  */
 export declare function poll<A>(handoff: Handoff<A>): UIO<Maybe<A>>;
 export declare const HandoffSignalTypeId: unique symbol;
-export declare const EmitTypeId: unique symbol;
-export type EmitTypeId = typeof EmitTypeId;
+declare const enum HandoffSignalTag {
+    Emit = 0,
+    Halt = 1,
+    End = 2
+}
 export declare class Emit<A> {
     readonly els: Conc<A>;
-    readonly _typeId: typeof HandoffSignalTypeId;
-    readonly _tag: typeof EmitTypeId;
+    readonly [HandoffSignalTypeId]: typeof HandoffSignalTypeId;
+    readonly _tag = HandoffSignalTag.Emit;
     constructor(els: Conc<A>);
 }
 export declare const HaltTypeId: unique symbol;
 export type HaltTypeId = typeof HaltTypeId;
 export declare class Halt<E> {
     readonly error: Cause<E>;
-    readonly _typeId: typeof HandoffSignalTypeId;
-    readonly _tag: typeof HaltTypeId;
+    readonly [HandoffSignalTypeId]: typeof HandoffSignalTypeId;
+    readonly _tag = HandoffSignalTag.Halt;
     constructor(error: Cause<E>);
 }
 export declare const EndTypeId: unique symbol;
 export type EndTypeId = typeof EndTypeId;
 export declare class End {
     readonly reason: SinkEndReason;
-    readonly _typeId: typeof HandoffSignalTypeId;
-    readonly _tag: typeof EndTypeId;
+    readonly [HandoffSignalTypeId]: typeof HandoffSignalTypeId;
+    readonly _tag = HandoffSignalTag.End;
     constructor(reason: SinkEndReason);
 }
 /**
@@ -99,7 +104,7 @@ export declare function halt<E>(error: Cause<E>): HandoffSignal<E, never>;
  * @tsplus static fncts.io.Stream.HandoffSignalOps End
  * @tsplus location "@fncts/io/Stream/internal/Handoff"
  */
-export declare function end<C>(reason: SinkEndReason): HandoffSignal<never, never>;
+export declare function end(reason: SinkEndReason): HandoffSignal<never, never>;
 /**
  * @tsplus pipeable fncts.io.Stream.HandoffSignal match
  * @tsplus location "@fncts/io/Stream/internal/Handoff"
@@ -109,3 +114,4 @@ export declare function matchSignal<E, A, B, D, F>(cases: {
     Halt: (_: Halt<E>) => D;
     End: (_: End) => F;
 }): (signal: HandoffSignal<E, A>) => B | D | F;
+export {};

package/Stream/internal/Pull.d.ts

@@ -1,8 +1,8 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Dequeue } from "@fncts/io/Queue/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Queue } from "../../Queue.js";
 import type { Take } from "./Take.js";
 export type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
 /**
@@ -25,7 +25,7 @@ export declare function emitChunk<A>(as: Conc<A>): UIO<Conc<A>>;
  * @tsplus static fncts.io.Stream.PullOps fromQueue
  * @tsplus location "@fncts/io/Stream/internal/Pull"
  */
-export declare function fromQueue<E, A>(d: Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>>;
+export declare function fromQueue<E, A>(d: Queue.Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>>;
 /**
  * @tsplus static fncts.io.Stream.PullOps fail
  * @tsplus location "@fncts/io/Stream/internal/Pull"

package/Stream/internal/SinkEndReason.d.ts

@@ -6,11 +6,11 @@ export declare const enum SinkEndReasonTag {
 }
 export declare const SinkEndReasonTypeId: unique symbol;
 export declare class ScheduleEnd {
-    readonly _typeId: typeof SinkEndReasonTypeId;
+    readonly [SinkEndReasonTypeId]: typeof SinkEndReasonTypeId;
     readonly _tag = SinkEndReasonTag.ScheduleEnd;
 }
 export declare class UpstreamEnd {
-    readonly _typeId: typeof SinkEndReasonTypeId;
+    readonly [SinkEndReasonTypeId]: typeof SinkEndReasonTypeId;
     readonly _tag = SinkEndReasonTag.UpstreamEnd;
 }
 /**

package/Subject/Atomic.d.ts

@@ -0,0 +1,22 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Emitter } from "@fncts/io/Push/definition";
+import type { Subject } from "@fncts/io/Subject/definition";
+import { Multicast } from "@fncts/io/Push";
+import { PushTypeId, PushVariance } from "@fncts/io/Push/definition";
+import { SubjectTypeId } from "@fncts/io/Subject/definition";
+export declare class AtomicSubject<E, A> implements Subject<never, E, A> {
+    readonly [SubjectTypeId]: SubjectTypeId;
+    readonly [PushTypeId]: PushTypeId;
+    [PushVariance]: {
+        readonly _R: (_: never) => never;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+    readonly stream: Multicast<never, E, A>;
+    run<R>(emitter: Emitter<R, E, A>): IO<R | Scope, never, unknown>;
+    emit(value: A): IO<never, never, void>;
+    failCause(cause: Cause<E>): IO<never, never, void>;
+    end: import("../IO").IO<never, never, void>;
+}

package/Subject/api.d.ts

@@ -0,0 +1,13 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Subject } from "./definition.js";
+/**
+ * @tsplus static fncts.io.Push.SubjectOps unsafeMake
+ * @tsplus location "@fncts/io/Subject/api"
+ */
+export declare function unsafeMake<E, A>(): Subject<never, E, A>;
+/**
+ * @tsplus static fncts.io.Push.SubjectOps make
+ * @tsplus static fncts.io.Push.SubjectOps __call
+ * @tsplus location "@fncts/io/Subject/api"
+ */
+export declare function make<E, A>(): UIO<Subject<never, E, A>>;

package/Subject/definition.d.ts

@@ -0,0 +1,15 @@
+import type { Emitter, Push } from "../Push.js";
+export declare const SubjectTypeId: unique symbol;
+export type SubjectTypeId = typeof SubjectTypeId;
+/**
+ * @tsplus type fncts.io.Push.Subject
+ */
+export interface Subject<R, E, A> extends Push<R, E, A>, Emitter<R, E, A> {
+    readonly [SubjectTypeId]: SubjectTypeId;
+}
+/**
+ * @tsplus type fncts.io.Push.SubjectOps
+ */
+export interface SubjectOps {
+}
+export declare const Subject: SubjectOps;

package/Subject.d.ts

@@ -0,0 +1,3 @@
+export * from "./Subject/api.js";
+export * from "./Subject/Atomic.js";
+export * from "./Subject/definition.js";

package/SubscriptionRef.d.ts

@@ -1,17 +1,13 @@
 import { TSemaphore } from "@fncts/io/TSemaphore/definition";
 import { Hub } from "@fncts/io/Hub/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref, PRef } from "@fncts/io/Ref/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
-import { Synchronized } from "@fncts/io/Ref";
+import { PSynchronizedInternal } from "@fncts/io/Ref";
 import { Stream } from "@fncts/io/Stream";
 export declare const SubscriptionRefTypeId: unique symbol;
 export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
-/**
- * @tsplus type fncts.io.SubscriptionRef
- * @tsplus companion fncts.io.SubscriptionRefOps
- */
-export declare class SubscriptionRef<A> extends Synchronized<A> {
+export declare class SubscriptionRefInternal<A> extends PSynchronizedInternal<never, never, never, never, A, A> {
     readonly semaphore: TSemaphore;
     readonly hub: Hub<A>;
     readonly ref: Ref<A>;
@@ -21,6 +17,19 @@ export declare class SubscriptionRef<A> extends Synchronized<A> {
     set(a: A, __tsplusTrace?: string): UIO<void>;
     modifyIO<R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<R1, E1, B>;
 }
+/**
+ * @tsplus type fncts.io.SubscriptionRef
+ */
+export interface SubscriptionRef<A> extends PRef.Synchronized<never, never, never, never, A, A> {
+    readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId;
+}
+/**
+ * @tsplus type fncts.io.SubscriptionRefOps
+ */
+export interface SubscriptionRefOps {
+}
+export declare const SubscriptionRef: SubscriptionRefOps;
+export declare function concrete<A>(_: SubscriptionRef<A>): asserts _ is SubscriptionRefInternal<A>;
 /**
  * @tsplus static fncts.io.SubscriptionRefOps make
  * @tsplus static fncts.io.SubscriptionRefOps __call

package/SupervisorPatch.d.ts

@@ -13,7 +13,7 @@ export declare const enum SupervisorPatchTag {
  * @tsplus companion fncts.io.SupervisorPatchOps
  */
 export declare abstract class SupervisorPatch {
-    readonly _typeId: SupervisorPatchTypeId;
+    readonly [SupervisorPatchTypeId]: SupervisorPatchTypeId;
 }
 export declare class AddSupervisor extends SupervisorPatch {
     readonly supervisor: Supervisor<any>;

package/TExit/definition.d.ts

@@ -1,5 +1,5 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 /**
  * @tsplus type fncts.TExit
@@ -29,7 +29,7 @@ export type FailTypeId = typeof FailTypeId;
 export declare function isTExit(u: unknown): u is TExit<unknown, unknown>;
 export declare class Fail<E> {
     readonly value: E;
-    readonly _typeId: TExitTypeId;
+    readonly [TExitTypeId]: TExitTypeId;
     readonly _tag = TExitTag.Fail;
     constructor(value: E);
     get [Symbol.hash](): number;
@@ -42,7 +42,7 @@ export declare class Fail<E> {
 export declare function isFail<E, A>(self: TExit<E, A>): self is Fail<E>;
 export declare class Succeed<A> {
     readonly value: A;
-    readonly _typeId: TExitTypeId;
+    readonly [TExitTypeId]: TExitTypeId;
     readonly _tag = TExitTag.Succeed;
     constructor(value: A);
     get [Symbol.hash](): number;
@@ -55,7 +55,7 @@ export declare class Succeed<A> {
 export declare function isSucceed<E, A>(self: TExit<E, A>): self is Succeed<A>;
 export declare class Halt {
     readonly value: unknown;
-    readonly _typeId: TExitTypeId;
+    readonly [TExitTypeId]: TExitTypeId;
     readonly _tag = TExitTag.Halt;
     constructor(value: unknown);
     get [Symbol.hash](): number;
@@ -68,7 +68,7 @@ export declare class Halt {
 export declare function isHalt<E, A>(self: TExit<E, A>): self is Halt;
 export declare class Interrupt {
     readonly fiberId: FiberId;
-    readonly _typeId: symbol;
+    readonly [TExitTypeId]: symbol;
     readonly _tag = TExitTag.Interrupt;
     constructor(fiberId: FiberId);
     get [Symbol.hash](): number;
@@ -80,7 +80,7 @@ export declare class Interrupt {
  */
 export declare function isInterrupt<E, A>(self: TExit<E, A>): self is Interrupt;
 export declare class Retry {
-    readonly _typeId: TExitTypeId;
+    readonly [TExitTypeId]: TExitTypeId;
     readonly _tag = TExitTag.Retry;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;

package/TFuture/definition.d.ts

@@ -2,7 +2,7 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { UTRef } from "../TRef.js";
+import type { TRef } from "../TRef.js";
 interface TFutureN extends HKT {
     readonly type: TFuture<this["E"], this["A"]>;
 }
@@ -11,7 +11,7 @@ interface TFutureN extends HKT {
  */
 export interface TFuture<E, A> extends Newtype<{
     readonly TFuture: unique symbol;
-}, UTRef<Maybe<Either<E, A>>>> {
+}, TRef<Maybe<Either<E, A>>>> {
 }
 /**
  * @tsplus type fncts.io.TFutureOps

package/TReentrantLock/definition.d.ts

@@ -1,4 +1,4 @@
-import { UTRef } from "@fncts/io/TRef/definition";
+import { TRef } from "@fncts/io/TRef/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 /**
@@ -21,8 +21,8 @@ import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
  * @tsplus companion fncts.io.TReentrantLockOps
  */
 export declare class TReentrantLock {
-    readonly data: UTRef<LockState>;
-    constructor(data: UTRef<LockState>);
+    readonly data: TRef<LockState>;
+    constructor(data: TRef<LockState>);
 }
 export interface Lock {
     readonly readLocks: number;

package/TRef/api.d.ts

@@ -1,85 +1,84 @@
 import { STM } from "@fncts/io/STM/definition";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Journal } from "../STM/internal/Journal.js";
-import type { TRef } from "../TRef/definition.js";
+import type { PTRef } from "../TRef/definition.js";
 /**
  * Retrieves the value of the `TRef`.
  * @tsplus getter fncts.io.TRef get
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>, __tsplusTrace?: string): STM<never, EB, B>;
+export declare function get<EA, EB, A, B>(self: PTRef<EA, EB, A, B>, __tsplusTrace?: string): STM<never, EB, B>;
 /**
  * Updates the value of the variable, returning a function of the specified
  * value.
  * @tsplus pipeable fncts.io.TRef modify
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, B>;
+export declare function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, B>;
 /**
  * Sets the value of the `TRef`.
  * @tsplus pipeable fncts.io.TRef set
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function set<A>(a: A, __tsplusTrace?: string): <EA, EB, B>(self: TRef<EA, EB, A, B>) => import("../STM/definition.js").STM<never, EA, void>;
+export declare function set<A>(a: A, __tsplusTrace?: string): <EA, EB, B>(self: PTRef<EA, EB, A, B>) => import("../STM.js").STM<never, EA, void>;
 /**
  * Unsafely retrieves the value of the `TRef`.
  * @tsplus pipeable fncts.io.TRef unsafeGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function unsafeGet(journal: Journal, __tsplusTrace?: string): <EA, EB, A, B>(self: TRef<EA, EB, A, B>) => A;
+export declare function unsafeGet(journal: Journal, __tsplusTrace?: string): <EA, EB, A, B>(self: PTRef<EA, EB, A, B>) => A;
 /**
  * Updates the value of the variable, returning a function of the specified
  * value.
  * @tsplus pipeable fncts.io.TRef modifyJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function modifyJust<A, B>(b: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, B>;
+export declare function modifyJust<A, B>(b: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, B>;
 /**
  * Sets the value of the `TRef` and returns the old value.
  * @tsplus pipeable fncts.io.TRef getAndSet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates the value of the variable and returns the old value.
  * @tsplus pipeable fncts.io.TRef getAndUpdate
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates some values of the variable but leaves others alone, returning the
  * old value.
  * @tsplus pipeable fncts.io.TRef getAndUpdateJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates the value of the variable.
  * @tsplus pipeable fncts.io.TRef update
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, void>;
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, void>;
 /**
  * Updates some values of the variable but leaves others alone.
  * @tsplus pipeable fncts.io.TRef updateJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, void>;
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, void>;
 /**
  * Updates the value of the variable and returns the new value.
  * @tsplus pipeable fncts.io.TRef updateAndGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates some values of the variable but leaves others alone.
  * @tsplus pipeable fncts.io.TRef updateJustAndGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * @tsplus pipeable fncts.io.TRef unsafeSet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function unsafeSet<A>(journal: Journal, a: A, __tsplusTrace?: string): <EA, EB, B>(self: TRef<EA, EB, A, B>) => void;
+export declare function unsafeSet<A>(journal: Journal, a: A, __tsplusTrace?: string): <EA, EB, B>(self: PTRef<EA, EB, A, B>) => void;