@fncts/io 0.0.49 → 0.0.51

package/Ref/Synchronized/definition.d.ts

@@ -1,6 +1,6 @@
 import { Semaphore } from "@fncts/io/Semaphore";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { PRef } from "../definition.js";
+import type { PRef, RefVariance } from "../definition.js";
 import { IO } from "@fncts/io/IO";
 import { RefInternal } from "../definition.js";
 export declare const SynchronizedTypeId: unique symbol;
@@ -21,24 +21,47 @@ export interface PSynchronizedOps {
  * @tsplus location "@fncts/io/Ref/Synchronized/definition"
  */
 export declare const Synchronized: PSynchronizedOps;
+export interface ModifiableSynchronized<RA, RB, EA, EB, A, B> {
+    readonly [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, C>;
+}
+export interface MappableSynchronized<RA, RB, EA, EB, A, B> {
+    readonly [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    matchIO<RC, RD, EC, ED, C, D>(mapSetError: (_: EA) => EC, mapGetError: (_: EB) => ED, mapSet: (_: C) => IO<RC, EC, A>, mapGet: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronized<RA | RC, RB | RD, EC, ED, C, D>;
+    matchAllIO<RC, RD, EC, ED, C, D>(mapSetError: (_: EA) => EC, mapGetError: (_: EB) => ED, mapSetGetError: (_: EB) => EC, mapSet: (_: C) => (_: B) => IO<RC, EC, A>, mapGet: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronized<RA | RC | RB, RB | RD, EC, ED, C, D>;
+}
 /**
  * @tsplus type fncts.io.Ref.Synchronized
  */
 export declare class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
-    readonly semaphore: Semaphore;
-    readonly unsafeGet: IO<RB, EB, B>;
-    readonly unsafeSet: (a: A) => IO<RA, EA, void>;
+    protected semaphore: Semaphore;
+    protected unsafeGet: IO<RB, EB, B>;
+    protected unsafeSet: (a: A) => IO<RA, EA, void>;
     readonly [SynchronizedTypeId]: SynchronizedTypeId;
     constructor(semaphore: Semaphore, unsafeGet: IO<RB, EB, B>, unsafeSet: (a: A) => IO<RA, EA, void>);
     get get(): IO<RB, EB, B>;
     set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
     modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<RA | RB, EA | EB, C>;
     modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, C>;
-    matchAllIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC | RB, RB | RD, EC, ED, C, D>;
-    matchIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC, RB | RD, EC, ED, C, D>;
-    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
-    matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
-    withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+    matchAllIO<RC, RD, EC, ED, C, D>(mapSetError: (_: EA) => EC, mapGetError: (_: EB) => ED, mapSetGetError: (_: EB) => EC, mapSet: (_: C) => (_: B) => IO<RC, EC, A>, mapGet: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC | RB, RB | RD, EC, ED, C, D>;
+    matchIO<RC, RD, EC, ED, C, D>(mapSetError: (_: EA) => EC, mapGetError: (_: EB) => ED, mapSet: (_: C) => IO<RC, EC, A>, mapGet: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA | RC, RB | RD, EC, ED, C, D>;
+    match<EC, ED, C, D>(mapSetError: (_: EA) => EC, mapGetError: (_: EB) => ED, mapSet: (_: C) => Either<EC, A>, mapGet: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(mapSetError: (_: EA) => EC, mapGetError: (_: EB) => ED, mapSetGetError: (_: EB) => EC, mapSet: (_: C) => (_: B) => Either<EC, A>, mapGet: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
+    protected withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 }
 /**
  * @tsplus macro remove

package/Ref/definition.d.ts

@@ -65,6 +65,18 @@ export interface ModifiableRef<RA, RB, EA, EB, A, B> {
     };
     modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
 }
+export interface MappableRef<RA, RB, EA, EB, A, B> {
+    readonly [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA, RB, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA | RB, RB, EC, ED, C, D>;
+}
 export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B>, ReadableRef<RB, EB, B>, WritableRef<RA, EA, A>, ModifiableRef<RA, RB, EA, EB, A, B> {
     readonly [RefTypeId]: RefTypeId;
     [RefVariance]: {

package/STM/api.d.ts

@@ -55,7 +55,7 @@ export declare function environmentWith<R, A>(f: (r: Environment<R>) => A, __tsp
  * @tsplus static fncts.io.STMOps environmentWithSTM
  * @tsplus location "@fncts/io/STM/api"
  */
-export declare function environmentWithSTM<R0, R, E, A>(f: (r: Environment<R0>) => STM<R, E, A>, __tsplusTrace?: string): STM<R0 | R, E, A>;
+export declare function environmentWithSTM<R0, R, E, A>(f: (r: Environment<R0>) => STM<R, E, A>, __tsplusTrace?: string): STM<R | R0, E, A>;
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.

package/Scope/api.d.ts

@@ -1,8 +1,8 @@
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { Exit } from "@fncts/base/data/Exit/definition";
+import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { Closeable } from "./definition.js";
 /**
@@ -15,6 +15,11 @@ export declare function addFinalizer(finalizer: Lazy<UIO<any>>, __tsplusTrace?:
  * @tsplus location "@fncts/io/Scope/api"
  */
 export declare function makeAddFinalizer(finalizer: Lazy<UIO<void>>, __tsplusTrace?: string): IO<Scope, never, void>;
+/**
+ * @tsplus static fncts.io.ScopeOps addFinalizerExit
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function makeAddFinalizerExit(finalizer: (exit: Exit<any, any>) => UIO<any>, __tsplusTrace?: string): IO<Scope, never, void>;
 /**
  * @tsplus static fncts.io.ScopeOps concurrent
  * @tsplus static fncts.io.Scope.CloseableOps concurrent
@@ -63,3 +68,13 @@ export declare function unsafeMakeWith(executionStrategy: ExecutionStrategy, __t
  * @tsplus location "@fncts/io/Scope/api"
  */
 export declare function use<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): (self: Scope.Closeable) => IO<Exclude<R, Scope>, E, A>;
+/**
+ * @tsplus getter fncts.io.Scope awaitClose
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function awaitClose(scope: Scope): UIO<void>;
+/**
+ * @tsplus static fncts.io.ScopeOps awaitClose
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare const wait: IO<Scope, never, void>;

package/Semaphore/definition.d.ts

@@ -13,8 +13,8 @@ import { Reservation } from "@fncts/io/Semaphore/Reservation";
  */
 export declare class Semaphore {
     readonly permits: number;
+    readonly ref: Ref<Either<ImmutableQueue<[Future<never, void>, number]>, number>>;
     constructor(permits: number);
-    ref: import("../Ref").Ref.Atomic<import("@fncts/base/data/Either").Either<import("@fncts/base/collection/immutable/Queue").Queue<[import("../Future").Future<never, void>, number]>, number>>;
     available(__tsplusTrace?: string): UIO<number>;
     tryReserve(n: number, __tsplusTrace?: string): UIO<Maybe<Reservation>>;
     reserve(n: number, __tsplusTrace?: string): UIO<Reservation>;

package/Sink/definition.d.ts

@@ -2,14 +2,13 @@ import { Channel } from "@fncts/io/Channel";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 /**
  * Sink is a data type that represent a channel that reads elements
- * of type `In`, handles input errors of type `InErr`, emits errors
- * of type `OutErr`, emits outputs of type `L` and ends with a value
- * of type `Z`.
+ * of type `In`, emits errors of type `OutErr`, emits outputs of type `Out` and ends with a value
+ * of type `Done`.
  *
  * @tsplus type fncts.io.Sink
  * @tsplus companion fncts.io.SinkOps
  */
-export declare class Sink<R, E, In, L, Z> {
-    readonly channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>;
-    constructor(channel: Channel<R, never, Conc<In>, unknown, E, Conc<L>, Z>);
+export declare class Sink<Env, OutErr, In, Out, Done> {
+    readonly channel: Channel<Env, never, Conc<In>, unknown, OutErr, Conc<Out>, Done>;
+    constructor(channel: Channel<Env, never, Conc<In>, unknown, OutErr, Conc<Out>, Done>);
 }

package/Subject/Atomic.d.ts

@@ -1,11 +1,15 @@
-import { IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
-import type { Sink } from "@fncts/io/Push/definition";
-import type { Subject } from "@fncts/io/Subject/definition";
-import { Multicast } from "@fncts/io/Push";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import type { Scope } from "../Scope.js";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
+import { HashSet as MutableHashSet } from "@fncts/base/collection/mutable/HashSet";
 import { PushTypeId, PushVariance } from "@fncts/io/Push/definition";
+import { PSubject } from "@fncts/io/Subject/definition";
 import { SubjectTypeId } from "@fncts/io/Subject/definition";
-export declare class AtomicSubject<E, A> implements Subject<never, E, A> {
+import { IO } from "../IO.js";
+export declare class AtomicSubject<E, A> extends PSubject<Scope, never, E, E, A, A> {
     readonly [SubjectTypeId]: SubjectTypeId;
     readonly [PushTypeId]: PushTypeId;
     [PushVariance]: {
@@ -13,8 +17,14 @@ export declare class AtomicSubject<E, A> implements Subject<never, E, A> {
         readonly _E: (_: never) => E;
         readonly _A: (_: never) => A;
     };
-    readonly stream: Multicast<never, E, A>;
-    run<R>(emitter: Sink<R, E, A>): IO<R, never, unknown>;
-    event(value: A): IO<never, never, void>;
-    error(cause: Cause<E>): IO<never, never, void>;
+    get subscribers(): number;
+    protected sinks: MutableHashSet<readonly [UnsafeSink<any, E, A>, import("@fncts/base/data/Environment.js").Environment<any>, import("../Scope.js").Closeable]>;
+    protected interruptScopes: IO<never, never, void>;
+    readonly interrupt: IO<never, never, void>;
+    run<R1>(sink: UnsafeSink<R1, E, A>): IO<Scope | R1, never, void>;
+    onSuccess(value: A): IO<never, never, void>;
+    onFailure(cause: Cause<E>): IO<never, never, void>;
+    protected addSink<R, R1, B>(sink: UnsafeSink<R, E, A>, f: (scope: Scope) => IO<R1, never, B>): IO<Scope | R1, never, B>;
+    protected unsafeOnSuccess(a: A): IO<never, never, void>;
+    protected unsafeOnFailure(cause: Cause<E>): IO<never, never, void>;
 }

package/Subject/DeferredRef.d.ts

@@ -0,0 +1,17 @@
+import { Future } from "@fncts/io/Future";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Maybe, Nothing } from "@fncts/base/data/Maybe/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Equatable } from "@fncts/base/data/Equatable";
+import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { External, IO } from "../IO.js";
+export declare class FutureRef<E, A> extends External<never, E, A> {
+    readonly fiberId: FiberId;
+    readonly current: AtomicReference<Maybe<Exit<E, A>>>;
+    version: number;
+    future: Future<E, A>;
+    constructor(fiberId: FiberId, current: AtomicReference<Maybe<Exit<E, A>>>);
+    toIO: IO<never, E, A>;
+    done(exit: Exit<E, A>): boolean;
+    reset(): void;
+}

package/Subject/Hold.d.ts

@@ -0,0 +1,19 @@
+import { Maybe, Nothing, Just } from "@fncts/base/data/Maybe/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import type { Scope } from "../Scope.js";
+import type { Subject } from "../Subject.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { UnsafeSink } from "@fncts/io/Push/Sink";
+import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { IO } from "../IO.js";
+import { AtomicSubject } from "./Atomic.js";
+export interface Hold<E, A> extends Subject<never, E, A> {
+    value: AtomicReference<Maybe<Exit<E, A>>>;
+}
+export declare class HoldSubject<E, A> extends AtomicSubject<E, A> implements Hold<E, A> {
+    readonly value: AtomicReference<Maybe<Exit<E, A>>>;
+    onSuccess(value: A): IO<never, never, void>;
+    onFailure(cause: Cause<E>): IO<never, never, void>;
+    run<R1>(sink: UnsafeSink<R1, E, A>): IO<Scope | R1, never, void>;
+    interrupt: IO<never, never, void>;
+}

package/Subject/RefSubject/Atomic.d.ts

@@ -0,0 +1,43 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { Semaphore } from "@fncts/io/Semaphore";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { MaybeTag } from "@fncts/base/data/Maybe/definition";
+import { NoSuchElementError } from "@fncts/base/data/exceptions";
+import { Either } from "@fncts/base/data/Either/definition";
+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 { PSynchronizedInternal } from "@fncts/io/Ref/Synchronized/definition";
+import { PRefSubject } from "./RefSubject.js";
+export declare class Atomic<R, E, A> extends PRefSubject<never, never, E, E, E, A, A> {
+    readonly fiberId: FiberId;
+    readonly initial: IO<R, E, A>;
+    readonly runtime: Runtime<R | Scope>;
+    readonly scope: Scope.Closeable;
+    private futureRef;
+    private subject;
+    private fiber;
+    readonly semaphore: import("../../Semaphore.js").Semaphore;
+    constructor(fiberId: FiberId, initial: IO<R, E, A>, runtime: Runtime<R | Scope>, scope: Scope.Closeable);
+    readonly interrupt: IO<never, never, void>;
+    readonly subscribers: number;
+    run<R1>(sink: UnsafeSink<R1, E, A>): IO<Scope | R1, never, void>;
+    onFailure(cause: Cause<E>): IO<never, never, void>;
+    onSuccess: (a: A, __tsplusTrace?: string) => IO<never, never, void>;
+    modify<C>(f: (a: A) => readonly [C, A], __tsplusTrace?: string): IO<never, E, C>;
+    modifyIO<R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<R1, E1 | E, 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>;
+    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>;
+    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>;
+    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>;
+    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>;
+    set(a: A, __tsplusTrace?: string): IO<never, never, void>;
+    get get(): IO<never, E, A>;
+    private sendEvent;
+    private getOrInit;
+    private interruptFiber;
+    private init;
+}

package/Subject/RefSubject/Derived.d.ts

@@ -0,0 +1,43 @@
+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 { type PSynchronized } from "@fncts/io/Ref";
+import { PRefSubject } from "./RefSubject.js";
+export declare class Derived<EnvIn, EnvOut, ErrIn, ErrOut, ErrInRef, In, Out> extends PRefSubject<EnvIn, EnvOut, ErrIn, ErrOut, ErrInRef, In, Out> {
+    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;
+    constructor(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);
+    get subscribers(): number;
+    get interrupt(): IO<never, never, void>;
+    onSuccess(value: In): IO<EnvIn, never, void>;
+    onFailure(cause: Cause<ErrIn>): IO<EnvIn, never, void>;
+    get get(): IO<EnvOut, ErrOut, Out>;
+    set(a: In, __tsplusTrace?: string): IO<EnvIn, ErrInRef, void>;
+    modify<C>(f: (b: Out) => readonly [C, In], __tsplusTrace?: string): IO<EnvIn | EnvOut, ErrOut | ErrInRef, C>;
+    modifyIO<R1, E1, C>(f: (b: Out) => IO<R1, E1, readonly [C, In]>, __tsplusTrace?: string): IO<EnvIn | EnvOut | R1, ErrOut | ErrInRef | E1, 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>;
+    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>;
+    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>;
+    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>;
+    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>;
+    run<R1>(sink: UnsafeSink<R1, ErrOut, Out>): IO<Scope | EnvOut | R1, never, void>;
+}

package/Subject/RefSubject/RefSubject.d.ts

@@ -0,0 +1,37 @@
+import { PRef } from "@fncts/io/Ref/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+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 declare 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;
+    readonly [RefTypeId]: RefTypeId;
+    [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/Subject/RefSubject/constructors.d.ts

@@ -0,0 +1,15 @@
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
+import { Eq } from "@fncts/base/data/Eq/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import type { RefSubject } from "@fncts/io/Subject/RefSubject/RefSubject";
+export interface RefSubjectOptions<A> {
+    executionStrategy?: ExecutionStrategy;
+    eq?: Eq<A>;
+}
+/**
+ * @tsplus static fncts.io.RefSubject.PRefSubjectOps fromIO
+ * @tsplus static fncts.io.RefSubject.RefSubjectOps fromIO
+ * @tsplus location "@fncts/io/Subject/RefSubject/constructors"
+ */
+export declare function fromIO<R, E, A>(initial: IO<R, E, A>, options?: RefSubjectOptions<A>): IO<Scope | R, never, RefSubject<never, E, A>>;

package/Subject/RefSubject.d.ts

@@ -0,0 +1,4 @@
+export type {} from "./RefSubject/constructors.js";
+export type {} from "./RefSubject/RefSubject.js";
+export type {} from "./RefSubject/Derived.js";
+export type {} from "./RefSubject/Atomic.js";

package/Subject/definition.d.ts

@@ -1,12 +1,24 @@
-import type { Push, Sink } from "../Push.js";
+import { Scope } from "@fncts/io/Scope/definition";
+import { URIO } from "@fncts/io/IO/definition";
+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 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>, Sink<R, E, A> {
+export declare 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;
     readonly [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/Subject.d.ts

@@ -1,3 +1,6 @@
 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";

package/SubscriptionRef.d.ts

@@ -8,7 +8,6 @@ import { Stream } from "@fncts/io/Stream";
 export declare const SubscriptionRefTypeId: unique symbol;
 export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
 export declare class SubscriptionRefInternal<A> extends PSynchronizedInternal<never, never, never, never, A, A> {
-    readonly semaphore: Semaphore;
     readonly hub: Hub<A>;
     readonly ref: Ref<A>;
     readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId;

package/Supervisor/definition.d.ts

@@ -49,8 +49,8 @@ export declare class Zip<A, B> extends Supervisor<readonly [A, B]> {
     readonly first: Supervisor<A>;
     readonly second: Supervisor<B>;
     readonly _tag = SupervisorTag.Zip;
+    readonly value: UIO<readonly [A, B]>;
     constructor(first: Supervisor<A>, second: Supervisor<B>);
-    value: import("../IO").IO<never, never, readonly [A, B]>;
     unsafeOnStart<R, E, A>(environment: Environment<R>, effect: IO<R, E, A>, parent: Maybe<Fiber.Runtime<any, any>>, fiber: Fiber.Runtime<E, A>): void;
     unsafeOnEnd<E, A>(value: Exit<E, A>, fiber: Fiber.Runtime<E, A>): void;
     unsafeOnEffect<E, A>(fiber: Fiber.Runtime<E, A>, effect: IO<any, any, any>): void;

package/_cjs/Cached/api.cjs

@@ -41,12 +41,18 @@ function manual_1(acquire, __tsplusTrace) {
   return tsplus_module_6.flatMap(env => tsplus_module_6.map(ref => new Manual(ref, tsplus_module_7.provideEnvironment(env, __tsplusTrace)(acquire)), __tsplusTrace)(tsplus_module_8.fromAcquire(tsplus_module_6.result(acquire, __tsplusTrace), __tsplusTrace)), __tsplusTrace)(tsplus_module_7.environment(__tsplusTrace));
 }
 class Manual extends _internal.CachedInternal {
+  ref;
+  acquire;
   constructor(ref, acquire) {
     super();
     this.ref = ref;
     this.acquire = acquire;
-    this.get = tsplus_module_6.flatMap(tsplus_module_6.fromExitNow, fileName_1 + ":48:51")(this.ref.get);
-    this.refresh = this.ref.set(tsplus_module_6.map(tsplus_module_9.succeed, fileName_1 + ":49:60")(this.acquire), fileName_1 + ":49:43");
+  }
+  get get() {
+    return tsplus_module_6.flatMap(tsplus_module_6.fromExitNow, fileName_1 + ":50:32")(this.ref.get);
+  }
+  get refresh() {
+    return this.ref.set(tsplus_module_6.map(tsplus_module_9.succeed, fileName_1 + ":54:41")(this.acquire), fileName_1 + ":54:24");
   }
 }
 /**

package/_cjs/Cached/api.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"api.cjs","names":["_definition","require","_internal","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","manual","exports","manual_1","refresh","refresh_1","auto","acquire","policy","__tsplusTrace","tsplus_module_6","flatMap","map","tsplus_module_5","acquireRelease","tsplus_module_3","forkDaemon","tsplus_module_2","interruptible","tsplus_module_1","schedule","fiber","tsplus_module_4","interrupt","self","env","ref","Manual","tsplus_module_7","provideEnvironment","tsplus_module_8","fromAcquire","result","environment","CachedInternal","constructor","fromExitNow","fileName_1","tsplus_module_9","succeed"],"sources":["../../_src/Cached/api.ts"],"sourcesContent":[null],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAAA,WAAA,gBAAAC,OAAA;AACA,IAAAC,SAAA,gBAAAD,OAAA;AAA2D,SAAAE,wBAAAC,CAAA,EAAAC,CAAA,6BAAAC,OAAA,MAAAC,CAAA,OAAAD,OAAA,IAAAE,CAAA,OAAAF,OAAA,YAAAH,uBAAA,YAAAA,CAAAC,CAAA,EAAAC,CAAA,SAAAA,CAAA,IAAAD,CAAA,IAAAA,CAAA,CAAAK,UAAA,SAAAL,CAAA,MAAAM,CAAA,EAAAC,CAAA,EAAAC,CAAA,KAAAC,SAAA,QAAAC,OAAA,EAAAV,CAAA,iBAAAA,CAAA,uBAAAA,CAAA,yBAAAA,CAAA,SAAAQ,CAAA,MAAAF,CAAA,GAAAL,CAAA,GAAAG,CAAA,GAAAD,CAAA,QAAAG,CAAA,CAAAK,GAAA,CAAAX,CAAA,UAAAM,CAAA,CAAAM,GAAA,CAAAZ,CAAA,GAAAM,CAAA,CAAAO,GAAA,CAAAb,CAAA,EAAAQ,CAAA,gBAAAP,CAAA,IAAAD,CAAA,gBAAAC,CAAA,OAAAa,cAAA,CAAAC,IAAA,CAAAf,CAAA,EAAAC,CAAA,OAAAM,CAAA,IAAAD,CAAA,GAAAU,MAAA,CAAAC,cAAA,KAAAD,MAAA,CAAAE,wBAAA,CAAAlB,CAAA,EAAAC,CAAA,OAAAM,CAAA,CAAAK,GAAA,IAAAL,CAAA,CAAAM,GAAA,IAAAP,CAAA,CAAAE,CAAA,EAAAP,CAAA,EAAAM,CAAA,IAAAC,CAAA,CAAAP,CAAA,IAAAD,CAAA,CAAAC,CAAA,WAAAO,CAAA,KAAAR,CAAA,EAAAC,CAAA;;MA4B3CkB,MAAM,GAAAC,OAAA,CAAAD,MAAA,GAAAE,QAAA;MAyBNC,OAAO,GAAAF,OAAA,CAAAE,OAAA,GAAAC,SAAA;AAnDvB;;;AAGM,SAAUC,IAAIA,CAClBC,OAA+B,EAC/BC,MAA2B,EAC3BC,aAAsB;EAEtB,OAAAC,eAAA,CAAAC,OAAA,CACQV,MAAM,IAAAS,eAAA,CAAAE,GAAA,OAELX,MAAM,EALfQ,aAAA,EAIII,eAAA,CAAAC,cAAA,OAAAC,eAAA,CAAAC,UAAA,CAAkBC,eAAA,CAAAC,aAAA,CAAiBC,eAAA,CAAAC,QAAA,OAAwBZ,MAAM,EAJrEC,aAAA,EAAAJ,SAAA,CAIuCJ,MAAM,EAJ7CQ,aAAA,EAIsE,EAJtEA,aAAA,CAIuE,EAJvEA,aAAA,GAIqFY,KAAK,IAAIC,eAAA,CAAAC,SAAA,CAACF,KAAK,CAAU,EAJ9GZ,aAAA,CAI+G,GAJ/GA,aAAA,EAGmBN,QAAA,CAAcI,OAAO,EAHxCE,aAAA,CAGyC;AAI3C;AAEA;;;AAGM,SAAUf,GAAGA,CAAkB8B,IAA6B,EAAEf,aAAsB;EACxF;EACA,OAAOe,IAAI,CAAC9B,GAAG;AACjB;AAEA;;;AAGA,SAAAS,SACEI,OAA+B,EAC/BE,aAAsB;EAEtB,OAAAC,eAAA,CAAAC,OAAA,CACQc,GAAG,IAAAf,eAAA,CAAAE,GAAA,CACHc,GAAG,IACF,IAAIC,MAAM,CAACD,GAAG,EAAEE,eAAA,CAAAC,kBAAA,CAA2BJ,GAAG,EALvDhB,aAAA,EAKyBF,OAAO,CAAwB,CAAC,EALzDE,aAAA,EAIgBqB,eAAA,CAAAC,WAAA,CAAArB,eAAA,CAAAsB,MAAA,CAAsBzB,OAAO,EAJ7CE,aAAA,GAAAA,aAAA,CAIqD,GAJrDA,aAAA,EAGgBmB,eAAA,CAAAK,WAAA,CAHhBxB,aAAA,CAGmC;AAIrC;AAEA,MAAMkB,MAAwB,SAAQO,wBAA+B;EACnEC,YACWT,GAAqC,EACrCnB,OAAmC;IAE5C,KAAK,EAAE;IAHE,KAAAmB,GAAG,GAAHA,GAAG;IACH,KAAAnB,OAAO,GAAPA,OAAO;IAIlB,KAAAb,GAAG,GAAyBgB,eAAA,CAAAC,OAAA,CAAAD,eAAA,CAAA0B,WAAA,EAAAC,UAAA,iBAAI,CAACX,GAAG,CAAChC,GAAG,CAAwB;IAChE,KAAAU,OAAO,GAAqB,IAAI,CAACsB,GAAG,CAAC/B,GAAG,CAACe,eAAA,CAAAE,GAAA,CAAA0B,eAAA,CAAAC,OAAA,EAAAF,UAAA,iBAAI,CAAC9B,OAAO,CAAkB,EAAA8B,UAAA,YAAC;EAFxE;;AAKF;;;AAGA,SAAAhC,UAAyCmB,IAA6B,EAAEf,aAAsB;EAC5F;EACA,OAAOe,IAAI,CAACpB,OAAO;AACrB","ignoreList":[]}
+{"version":3,"file":"api.cjs","names":["_definition","require","_internal","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","default","has","get","set","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","manual","exports","manual_1","refresh","refresh_1","auto","acquire","policy","__tsplusTrace","tsplus_module_6","flatMap","map","tsplus_module_5","acquireRelease","tsplus_module_3","forkDaemon","tsplus_module_2","interruptible","tsplus_module_1","schedule","fiber","tsplus_module_4","interrupt","self","env","ref","Manual","tsplus_module_7","provideEnvironment","tsplus_module_8","fromAcquire","result","environment","CachedInternal","constructor","fromExitNow","fileName_1","tsplus_module_9","succeed"],"sources":["../../_src/Cached/api.ts"],"sourcesContent":[null],"mappings":"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","ignoreList":[]}

package/_cjs/Cached/definition.cjs

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", {
 exports.Cached = void 0;
 exports.concrete = concrete;
 var _internal = /*#__PURE__*/require("@fncts/io/Cached/internal");
-var _a;
 /**
  * A Cached is a possibly resourceful value that is loaded into memory, and
  * which can be refreshed either manually or automatically
@@ -15,15 +14,12 @@ var _a;
  * @tsplus companion fncts.io.CachedOps
  */
 class Cached {
-  constructor() {
-    this[_a] = _internal.CachedTypeId;
-  }
+  [_internal.CachedTypeId] = _internal.CachedTypeId;
 }
-exports.Cached = Cached;
-_a = _internal.CachedTypeId;
 /**
  * @tsplus macro remove
  */
+exports.Cached = Cached;
 function concrete(_) {
   //
 }

package/_cjs/Cached/definition.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"definition.cjs","names":["_internal","require","Cached","constructor","_a","CachedTypeId","exports","concrete","_"],"sources":["../../_src/Cached/definition.ts"],"sourcesContent":[null],"mappings":";;;;;;;AAEA,IAAAA,SAAA,gBAAAC,OAAA;;AAEA;;;;;;;AAOM,MAAOC,MAAM;EAAnBC,YAAA;IACW,KAAAC,EAAA,CAAc,GAAiBC,sBAAY;EAKtD;;AAACC,OAAA,CAAAJ,MAAA,GAAAA,MAAA;KALWG,sBAAY;AAOxB;;;AAGM,SAAUE,QAAQA,CAAOC,CAAe;EAC5C;AAAA","ignoreList":[]}
+{"version":3,"file":"definition.cjs","names":["_internal","require","Cached","CachedTypeId","exports","concrete","_"],"sources":["../../_src/Cached/definition.ts"],"sourcesContent":[null],"mappings":";;;;;;;AAEA,IAAAA,SAAA,gBAAAC,OAAA;AAEA;;;;;;;AAOM,MAAOC,MAAM;EACR,CAACC,sBAAY,IAAkBA,sBAAY;;AAOtD;;;AAAAC,OAAA,CAAAF,MAAA,GAAAA,MAAA;AAGM,SAAUG,QAAQA,CAAOC,CAAe;EAC5C;AAAA","ignoreList":[]}

package/_cjs/CancellerState.cjs

@@ -6,21 +6,18 @@ Object.defineProperty(exports, "__esModule", {
 exports.pending = exports.empty = exports.Registered = exports.Pending = exports.Empty = exports.CancellerState = void 0;
 exports.registered = registered;
 class Empty {
-  constructor() {
-    this._tag = "Empty" /* CancellerStateTag.Empty */;
-  }
+  _tag = "Empty" /* CancellerStateTag.Empty */;
 }
 exports.Empty = Empty;
 class Pending {
-  constructor() {
-    this._tag = "Pending" /* CancellerStateTag.Pending */;
-  }
+  _tag = "Pending" /* CancellerStateTag.Pending */;
 }
 exports.Pending = Pending;
 class Registered {
+  asyncCanceller;
+  _tag = "Registered" /* CancellerStateTag.Registered */;
   constructor(asyncCanceller) {
     this.asyncCanceller = asyncCanceller;
-    this._tag = "Registered" /* CancellerStateTag.Registered */;
   }
 }
 exports.Registered = Registered;

package/_cjs/CancellerState.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"CancellerState.cjs","names":["Empty","constructor","_tag","exports","Pending","Registered","asyncCanceller","CancellerState","empty","pending","registered"],"sources":["../_src/CancellerState.ts"],"sourcesContent":[null],"mappings":";;;;;;;AAMM,MAAOA,KAAK;EAAlBC,YAAA;IACW,KAAAC,IAAI;EACf;;AAACC,OAAA,CAAAH,KAAA,GAAAA,KAAA;AAEK,MAAOI,OAAO;EAApBH,YAAA;IACW,KAAAC,IAAI;EACf;;AAACC,OAAA,CAAAC,OAAA,GAAAA,OAAA;AAEK,MAAOC,UAAU;EAErBJ,YAAqBK,cAAiC;IAAjC,KAAAA,cAAc,GAAdA,cAAc;IAD1B,KAAAJ,IAAI;EAC4C;;AAC1DC,OAAA,CAAAE,UAAA,GAAAA,UAAA;AAYM,MAAME,cAAc,GAAAJ,OAAA,CAAAI,cAAA,GAAsB,EAAE;AAEnD;;;AAGO,MAAMC,KAAK,GAAAL,OAAA,CAAAK,KAAA,gBAAG,IAAIR,KAAK,EAAE;AAEhC;;;AAGO,MAAMS,OAAO,GAAAN,OAAA,CAAAM,OAAA,gBAAG,IAAIL,OAAO,EAAE;AAEpC;;;AAGM,SAAUM,UAAUA,CAACJ,cAAiC;EAC1D,OAAO,IAAID,UAAU,CAACC,cAAc,CAAC;AACvC","ignoreList":[]}
+{"version":3,"file":"CancellerState.cjs","names":["Empty","_tag","exports","Pending","Registered","asyncCanceller","constructor","CancellerState","empty","pending","registered"],"sources":["../_src/CancellerState.ts"],"sourcesContent":[null],"mappings":";;;;;;;AAMM,MAAOA,KAAK;EACPC,IAAI;;AACdC,OAAA,CAAAF,KAAA,GAAAA,KAAA;AAEK,MAAOG,OAAO;EACTF,IAAI;;AACdC,OAAA,CAAAC,OAAA,GAAAA,OAAA;AAEK,MAAOC,UAAU;EAEAC,cAAA;EADZJ,IAAI;EACbK,YAAqBD,cAAiC;IAAjC,KAAAA,cAAc,GAAdA,cAAc;EAAsB;;AAC1DH,OAAA,CAAAE,UAAA,GAAAA,UAAA;AAYM,MAAMG,cAAc,GAAAL,OAAA,CAAAK,cAAA,GAAsB,EAAE;AAEnD;;;AAGO,MAAMC,KAAK,GAAAN,OAAA,CAAAM,KAAA,gBAAG,IAAIR,KAAK,EAAE;AAEhC;;;AAGO,MAAMS,OAAO,GAAAP,OAAA,CAAAO,OAAA,gBAAG,IAAIN,OAAO,EAAE;AAEpC;;;AAGM,SAAUO,UAAUA,CAACL,cAAiC;EAC1D,OAAO,IAAID,UAAU,CAACC,cAAc,CAAC;AACvC","ignoreList":[]}

package/_cjs/Channel/UpstreamPullRequest/definition.cjs

@@ -5,16 +5,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.UpstreamPullRequest = exports.Pulled = exports.NoUpstream = void 0;
 class Pulled {
+  value;
+  _tag = "Pulled";
   constructor(value) {
     this.value = value;
-    this._tag = "Pulled";
   }
 }
 exports.Pulled = Pulled;
 class NoUpstream {
+  activeDownstreamCount;
+  _tag = "NoUpstream";
   constructor(activeDownstreamCount) {
     this.activeDownstreamCount = activeDownstreamCount;
-    this._tag = "NoUpstream";
   }
 }
 exports.NoUpstream = NoUpstream;

package/_cjs/Channel/UpstreamPullRequest/definition.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"definition.cjs","names":["Pulled","constructor","value","_tag","exports","NoUpstream","activeDownstreamCount","UpstreamPullRequest"],"sources":["../../../_src/Channel/UpstreamPullRequest/definition.ts"],"sourcesContent":[null],"mappings":";;;;;;AAAM,MAAOA,MAAM;EAEjBC,YAAqBC,KAAQ;IAAR,KAAAA,KAAK,GAALA,KAAK;IADjB,KAAAC,IAAI,GAAG,QAAQ;EACQ;;AACjCC,OAAA,CAAAJ,MAAA,GAAAA,MAAA;AAEK,MAAOK,UAAU;EAErBJ,YAAqBK,qBAA6B;IAA7B,KAAAA,qBAAqB,GAArBA,qBAAqB;IADjC,KAAAH,IAAI,GAAG,YAAY;EACyB;;AACtDC,OAAA,CAAAC,UAAA,GAAAA,UAAA;AAYM,MAAME,mBAAmB,GAAAH,OAAA,CAAAG,mBAAA,GAA2B,EAAE","ignoreList":[]}
+{"version":3,"file":"definition.cjs","names":["Pulled","value","_tag","constructor","exports","NoUpstream","activeDownstreamCount","UpstreamPullRequest"],"sources":["../../../_src/Channel/UpstreamPullRequest/definition.ts"],"sourcesContent":[null],"mappings":";;;;;;AAAM,MAAOA,MAAM;EAEIC,KAAA;EADZC,IAAI,GAAG,QAAQ;EACxBC,YAAqBF,KAAQ;IAAR,KAAAA,KAAK,GAALA,KAAK;EAAM;;AACjCG,OAAA,CAAAJ,MAAA,GAAAA,MAAA;AAEK,MAAOK,UAAU;EAEAC,qBAAA;EADZJ,IAAI,GAAG,YAAY;EAC5BC,YAAqBG,qBAA6B;IAA7B,KAAAA,qBAAqB,GAArBA,qBAAqB;EAAW;;AACtDF,OAAA,CAAAC,UAAA,GAAAA,UAAA;AAYM,MAAME,mBAAmB,GAAAH,OAAA,CAAAG,mBAAA,GAA2B,EAAE","ignoreList":[]}