@fncts/io 0.0.22 → 0.0.24

package/Ref/Derived.d.ts

@@ -4,9 +4,11 @@ import type { Atomic } from "./Atomic.js";
 import type { PRef } from "./definition.js";
 import { IO } from "@fncts/io/IO";
 import { RefInternal } from "./definition.js";
+export declare const DerivedTypeId: unique symbol;
+export type DerivedTypeId = typeof DerivedTypeId;
 export declare class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
     readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X;
-    readonly _tag = "Derived";
+    readonly [DerivedTypeId]: DerivedTypeId;
     constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X);
     match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, 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<never, never, EC, ED, C, D>;

package/Ref/Synchronized/constructors.d.ts

@@ -1,6 +1,11 @@
+import { Ref } from "@fncts/io/Ref/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO } from "@fncts/io/IO/definition";
-import { Ref } from "@fncts/io/Ref/definition";
+/**
+ * @tsplus static fncts.io.Ref.SynchronizedOps unsafeMake
+ * @tsplus location "@fncts/io/Ref/Synchronized/constructors"
+ */
+export declare function unsafeMakeSynchronized<A>(a: A, __tsplusTrace?: string): Ref.Synchronized<A>;
 /**
  * @tsplus static fncts.io.Ref.SynchronizedOps make
  * @tsplus location "@fncts/io/Ref/Synchronized/constructors"

package/Ref/Synchronized/definition.d.ts

@@ -3,11 +3,13 @@ import { Either } from "@fncts/base/data/Either/definition";
 import type { PRef } from "../definition.js";
 import { IO } from "@fncts/io/IO";
 import { RefInternal } from "../definition.js";
+export declare const SynchronizedTypeId: unique symbol;
+export type SynchronizedTypeId = typeof SynchronizedTypeId;
 /**
  * @tsplus type fncts.io.Ref.Synchronized
  */
 export interface PSynchronized<RA, RB, EA, EB, A, B> extends PRef<RA, RB, EA, EB, A, B> {
-    readonly _tag: "Synchronized";
+    readonly [SynchronizedTypeId]: SynchronizedTypeId;
 }
 /**
  * @tsplus type fncts.io.Ref.SynchronizedOps
@@ -26,7 +28,7 @@ export declare class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInte
     readonly semaphore: TSemaphore;
     readonly unsafeGet: IO<RB, EB, B>;
     readonly unsafeSet: (a: A) => IO<RA, EA, void>;
-    readonly _tag = "Synchronized";
+    readonly [SynchronizedTypeId]: SynchronizedTypeId;
     constructor(semaphore: TSemaphore, 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>;

package/Ref/definition.d.ts

@@ -2,7 +2,8 @@ import { IO } from "@fncts/io/IO/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import type { Atomic as Atomic_ } from "./Atomic.js";
 import type * as Synchro from "./Synchronized/definition.js";
-import { _A, _B, _EA, _EB, _RA, _RB } from "./symbols.js";
+export declare const RefVariance: unique symbol;
+export type RefVariance = typeof RefVariance;
 export declare const RefTypeId: unique symbol;
 export type RefTypeId = typeof RefTypeId;
 /**
@@ -10,12 +11,14 @@ export type RefTypeId = typeof RefTypeId;
  */
 export interface PRef<RA, RB, EA, EB, A, B> {
     readonly [RefTypeId]: RefTypeId;
-    readonly [_RA]: () => RA;
-    readonly [_RB]: () => RB;
-    readonly [_EA]: () => EA;
-    readonly [_EB]: () => EB;
-    readonly [_A]: (_: A) => void;
-    readonly [_B]: () => 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;
+    };
 }
 export type Ref<A> = PRef<never, never, never, never, A, A>;
 export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
@@ -36,34 +39,42 @@ export interface RefOps {
 }
 export declare const Ref: RefOps;
 export interface ReadableRef<RB, EB, B> {
-    readonly [_RB]: () => RB;
-    readonly [_EB]: () => EB;
-    readonly [_B]: () => B;
+    readonly [RefVariance]: {
+        readonly _RB: (_: never) => RB;
+        readonly _EB: (_: never) => EB;
+        readonly _B: (_: never) => B;
+    };
     readonly get: IO<RB, EB, B>;
 }
 export interface WritableRef<RA, EA, A> {
-    readonly [_RA]: () => RA;
-    readonly [_EA]: () => EA;
-    readonly [_A]: (_: A) => void;
+    readonly [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _EA: (_: never) => EA;
+        readonly _A: (_: A) => void;
+    };
     set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
 }
 export interface ModifiableRef<RA, RB, EA, EB, A, B> {
-    readonly [_RA]: () => RA;
-    readonly [_RB]: () => RB;
-    readonly [_EA]: () => EA;
-    readonly [_EB]: () => EB;
-    readonly [_A]: (_: A) => void;
-    readonly [_B]: () => 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;
+    };
     modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
 }
 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;
-    [_RA]: () => RA;
-    [_RB]: () => RB;
-    [_EA]: () => EA;
-    [_EB]: () => EB;
-    [_A]: (_: A) => void;
-    [_B]: () => B;
+    [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;
+    };
     /**
      * Folds over the error and value types of the `Ref`. This is a highly
      * polymorphic method that is capable of arbitrarily transforming the error

package/Ref.d.ts

@@ -4,7 +4,6 @@ export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
 export * from "./Ref/Derived.js";
 export * from "./Ref/DerivedAll.js";
-export * from "./Ref/symbols.js";
 export * from "./Ref/Synchronized.js";
 export * from "./Ref/Synchronized/api.js";
 export * from "./Ref/Synchronized/constructors.js";

package/RefSubject/definition.d.ts

@@ -1,4 +1,3 @@
-import { Ref } from "@fncts/io/Ref/definition";
 import { IO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
@@ -6,11 +5,13 @@ import type { Emitter } from "../Push.js";
 import type { Push } from "../Push.js";
 import type { ModifiableRef, ReadableRef, WritableRef } from "../Ref.js";
 import type { SynchronizedRefSubject } from "@fncts/io/RefSubject/Synchronized/definition";
+import { PushTypeId } from "../Push.js";
+import { PushVariance } from "../Push.js";
+import { RefVariance } from "../Ref.js";
 /**
  * @tsplus type fncts.io.Push.RefSubject
  */
 export interface RefSubject<out R, in out E, in A, out B> extends Push<R, E, B>, Emitter<R, E, A> {
-    readonly _A: (_: A) => B;
 }
 /**
  * @tsplus type fncts.io.Push.RefSubjectOps
@@ -22,15 +23,20 @@ export declare namespace RefSubject {
     type Synchronized<R, E, A, B> = SynchronizedRefSubject<R, E, A, B>;
 }
 export declare abstract class RefSubjectInternal<R, E, A, B> implements ReadableRef<R, never, B>, WritableRef<R, never, A>, ModifiableRef<R, R, never, never, A, B>, Push<R, E, B>, Emitter<R, E, A> {
-    [Ref._RA]: () => R;
-    [Ref._RB]: () => R;
-    [Ref._EA]: () => never;
-    [Ref._EB]: () => never;
-    [Ref._A]: (_: A) => void;
-    [Ref._B]: () => B;
-    _R: (_: never) => R;
-    _E: (_: never) => E;
-    _A: (_: A) => B;
+    readonly [PushTypeId]: PushTypeId;
+    [RefVariance]: {
+        readonly _RA: (_: never) => R;
+        readonly _RB: (_: never) => R;
+        readonly _EA: (_: never) => never;
+        readonly _EB: (_: never) => never;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    [PushVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: A) => B;
+    };
     abstract get get(): IO<R, never, B>;
     abstract set(value: A): IO<R, never, void>;
     abstract modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<R, never, C>;

package/Reloadable/definition.d.ts

@@ -1,6 +1,8 @@
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
 import { IO, UIO } from "@fncts/io/IO/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
+export declare const ReloadableVariance: unique symbol;
+export type ReloadableVariance = typeof ReloadableVariance;
 /**
  * @tsplus type fncts.io.Reloadable
  * @tsplus companion fncts.io.ReloadableOps
@@ -8,7 +10,9 @@ import { Tag } from "@fncts/base/data/Tag/definition";
 export declare class Reloadable<Service> {
     readonly scopedRef: ScopedRef<Service>;
     readonly reload: IO<never, unknown, void>;
-    _Service: (_: never) => Service;
+    [ReloadableVariance]: {
+        readonly _Service: (_: never) => Service;
+    };
     constructor(scopedRef: ScopedRef<Service>, reload: IO<never, unknown, void>);
     get get(): UIO<Service>;
     get reloadFork(): UIO<void>;

package/STM/api/atomically.d.ts

@@ -0,0 +1,9 @@
+import { STM } from "@fncts/io/STM/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus static fncts.io.STMOps atomically
+ * @tsplus getter fncts.io.STM commit
+ * @tsplus location "@fncts/io/STM/api/atomically"
+ */
+export declare function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;

package/STM/api.d.ts

@@ -56,12 +56,6 @@ export declare function environmentWith<R, A>(f: (r: Environment<R>) => A, __tsp
  * @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>;
-/**
- * @tsplus static fncts.io.STMOps atomically
- * @tsplus getter fncts.io.STM commit
- * @tsplus location "@fncts/io/STM/api"
- */
-export declare function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
@@ -372,3 +366,15 @@ export declare const unit: STM<never, never, void>;
  * @tsplus location "@fncts/io/STM/api"
  */
 export declare function zipWith<A, R1, E1, B, C>(that: STM<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, C>;
+/**
+ * @tsplus pipeable fncts.io.STM zipLeft
+ * @tsplus opipeable-operator fncts.io.STM <
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function zipLeft<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, A>;
+/**
+ * @tsplus pipeable fncts.io.STM zipRight
+ * @tsplus pipeable-operator fncts.io.STM >
+ * @tsplus location "@fncts/io/STM/api"
+ */
+export declare function zipRight<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: STM<R, E, A>) => STM<R1 | R, E1 | E, B>;

package/STM/definition.d.ts

@@ -2,6 +2,7 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
 import type { Journal } from "./internal/Journal.js";
 import type { _A, _E, _R } from "@fncts/base/types";
+import { IOOpCode, IOTypeId, IOVariance } from "@fncts/io/IO/definition";
 export declare const enum STMTag {
     Effect = "Effect",
     OnFailure = "OnFailure",
@@ -11,6 +12,8 @@ export declare const enum STMTag {
     SucceedNow = "SucceedNow",
     ContramapEnvironment = "ContramapEnvironment"
 }
+export declare const STMVariance: unique symbol;
+export type STMVariance = typeof STMVariance;
 export declare const STMTypeId: unique symbol;
 export type STMTypeId = typeof STMTypeId;
 /**
@@ -18,10 +21,20 @@ export type STMTypeId = typeof STMTypeId;
  * @tsplus companion fncts.io.STMOps
  */
 export declare abstract class STM<R, E, A> {
-    readonly _typeId: STMTypeId;
-    readonly _R: () => R;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [IOTypeId]: IOTypeId;
+    readonly ioOpCode = IOOpCode.Commit;
+    readonly trace?: string;
+    readonly [STMTypeId]: STMTypeId;
+    [IOVariance]: {
+        _R: () => R;
+        _E: () => E;
+        _A: () => A;
+    };
+    [STMVariance]: {
+        _R: () => R;
+        _E: () => E;
+        _A: () => A;
+    };
 }
 /**
  * @tsplus unify fncts.io.STM
@@ -34,43 +47,43 @@ export interface USTM<A> extends STM<never, never, A> {
 }
 export declare class Effect<R, E, A> extends STM<R, E, A> {
     readonly f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A;
-    readonly _tag = STMTag.Effect;
+    readonly stmOpCode = STMTag.Effect;
     constructor(f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A);
 }
 export declare class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
     readonly stm: STM<R, E, A>;
     readonly onFailure: (e: E) => STM<R, E1, A>;
-    readonly _tag = STMTag.OnFailure;
+    readonly stmOpCode = STMTag.OnFailure;
     constructor(stm: STM<R, E, A>, onFailure: (e: E) => STM<R, E1, A>);
     apply(a: A): STM<R, E, A>;
 }
 export declare class OnRetry<R, E, A> extends STM<R, E, A> {
     readonly stm: STM<R, E, A>;
     readonly onRetry: STM<R, E, A>;
-    readonly _tag = STMTag.OnRetry;
+    readonly stmOpCode = STMTag.OnRetry;
     constructor(stm: STM<R, E, A>, onRetry: STM<R, E, A>);
     apply(a: A): STM<R, E, A>;
 }
 export declare class OnSuccess<R, E, A, B> extends STM<R, E, B> {
     readonly stm: STM<R, E, A>;
     readonly apply: (a: A) => STM<R, E, B>;
-    readonly _tag = STMTag.OnSuccess;
+    readonly stmOpCode = STMTag.OnSuccess;
     constructor(stm: STM<R, E, A>, apply: (a: A) => STM<R, E, B>);
 }
 export declare class Succeed<A> extends STM<never, never, A> {
     readonly a: () => A;
-    readonly _tag = STMTag.Succeed;
+    readonly stmOpCode = STMTag.Succeed;
     constructor(a: () => A);
 }
 export declare class SucceedNow<A> extends STM<never, never, A> {
     readonly a: A;
-    readonly _tag = STMTag.SucceedNow;
+    readonly stmOpCode = STMTag.SucceedNow;
     constructor(a: A);
 }
 export declare class ContramapEnvironment<R, E, A, R0> extends STM<R0, E, A> {
     readonly stm: STM<R, E, A>;
     readonly f: (_: Environment<R0>) => Environment<R>;
-    readonly _tag = STMTag.ContramapEnvironment;
+    readonly stmOpCode = STMTag.ContramapEnvironment;
     constructor(stm: STM<R, E, A>, f: (_: Environment<R0>) => Environment<R>);
 }
 export declare function concrete<R, E, A>(_: STM<R, E, A>): asserts _ is Effect<R, E, A> | OnFailure<R, unknown, A, E> | OnSuccess<R, E, unknown, A> | OnRetry<R, E, A> | Succeed<A> | SucceedNow<A> | ContramapEnvironment<unknown, E, A, R>;
@@ -78,7 +91,7 @@ export declare const FailExceptionTypeId: unique symbol;
 export type FailExceptionTypeId = typeof FailExceptionTypeId;
 export declare class FailException<E> {
     readonly e: E;
-    readonly _typeId: FailExceptionTypeId;
+    readonly [FailExceptionTypeId]: FailExceptionTypeId;
     constructor(e: E);
 }
 export declare function isFailException(u: unknown): u is FailException<unknown>;
@@ -86,7 +99,7 @@ export declare const HaltExceptionTypeId: unique symbol;
 export type HaltExceptionTypeId = typeof HaltExceptionTypeId;
 export declare class HaltException<E> {
     readonly e: E;
-    readonly _typeId: HaltExceptionTypeId;
+    readonly [HaltExceptionTypeId]: HaltExceptionTypeId;
     constructor(e: E);
 }
 export declare function isHaltException(u: unknown): u is HaltException<unknown>;
@@ -94,13 +107,13 @@ export declare const InterruptExceptionTypeId: unique symbol;
 export type InterruptExceptionTypeId = typeof InterruptExceptionTypeId;
 export declare class InterruptException {
     readonly fiberId: FiberId;
-    readonly _typeId: InterruptExceptionTypeId;
+    readonly [InterruptExceptionTypeId]: InterruptExceptionTypeId;
     constructor(fiberId: FiberId);
 }
 export declare function isInterruptException(u: unknown): u is InterruptException;
 export declare const RetryExceptionTypeId: unique symbol;
 export type RetryExceptionTypeId = typeof RetryExceptionTypeId;
 export declare class RetryException {
-    readonly _typeId: RetryExceptionTypeId;
+    readonly [RetryExceptionTypeId]: RetryExceptionTypeId;
 }
 export declare function isRetryException(u: unknown): u is RetryException;

package/STM/internal/Entry.d.ts

@@ -8,7 +8,7 @@ export type EntryTypeId = typeof EntryTypeId;
  */
 export declare class Entry {
     readonly use: <X>(f: <S>(entry: ConcreteEntry<S>) => X) => X;
-    readonly _typeId: EntryTypeId;
+    readonly [EntryTypeId]: EntryTypeId;
     constructor(use: <X>(f: <S>(entry: ConcreteEntry<S>) => X) => X);
 }
 /**
@@ -24,7 +24,7 @@ export declare class ConcreteEntry<S> {
     protected newValue: S;
     readonly isNew: boolean;
     private _isChanged;
-    readonly _typeId: ConcreteEntryTypeId;
+    readonly [ConcreteEntryTypeId]: ConcreteEntryTypeId;
     constructor(tref: Atomic<S>, expected: Versioned<S>, newValue: S, isNew: boolean, _isChanged: boolean);
     unsafeSet(value: unknown): void;
     unsafeGet<B>(): B;

package/STM/internal/TryCommit.d.ts

@@ -9,13 +9,13 @@ export declare const enum TryCommitTag {
 }
 export declare class Done<E, A> {
     readonly exit: Exit<E, A>;
-    readonly _typeId: TryCommitTypeId;
+    readonly [TryCommitTypeId]: TryCommitTypeId;
     readonly _tag = TryCommitTag.Done;
     constructor(exit: Exit<E, A>);
 }
 export declare class Suspend {
     readonly journal: Journal;
-    readonly _typeId: TryCommitTypeId;
+    readonly [TryCommitTypeId]: TryCommitTypeId;
     readonly _tag = TryCommitTag.Suspend;
     constructor(journal: Journal);
 }

package/STM/internal/Versioned.d.ts

@@ -2,6 +2,6 @@ export declare const VersionedTypeId: unique symbol;
 export type VersionedTypeId = typeof VersionedTypeId;
 export declare class Versioned<A> {
     readonly value: A;
-    readonly _typeId: VersionedTypeId;
+    readonly [VersionedTypeId]: VersionedTypeId;
     constructor(value: A);
 }

package/STM.d.ts

@@ -1,5 +1,6 @@
 export * from "./STM/api.js";
 export * from "./STM/definition.js";
 export * from "./STM/driver.js";
+export * from "./STM/api/atomically.js";
 export * from "./STM/api/core-api.js";
 export * from "./STM/api/core-constructors.js";

package/Schedule/definition.d.ts

@@ -1,6 +1,8 @@
 import { IO } from "@fncts/io/IO/definition";
 import type { Decision } from "./Decision.js";
 import type { Driver as Driver_ } from "./Driver.js";
+export declare const ScheduleVariance: unique symbol;
+export type ScheduleVariance = typeof ScheduleVariance;
 /**
  * A `Schedule<Env, In, Out>` defines a recurring schedule, which consumes
  * values of type `In`, and which returns values of type `Out`.
@@ -32,9 +34,11 @@ import type { Driver as Driver_ } from "./Driver.js";
  * @tsplus companion fncts.io.ScheduleOps
  */
 export declare abstract class Schedule<Env, In, Out> {
-    readonly _Env: () => Env;
-    readonly _In: (_: In) => void;
-    readonly _Out: () => Out;
+    [ScheduleVariance]: {
+        readonly _Env: (_: never) => Env;
+        readonly _In: (_: In) => void;
+        readonly _Out: (_: never) => Out;
+    };
     readonly _State: unknown;
     abstract readonly initial: this["_State"];
     abstract step(now: number, inp: In, state: this["_State"], __tsplusTrace?: string): IO<Env, never, readonly [this["_State"], Out, Decision]>;

package/Scope/definition.d.ts

@@ -9,7 +9,7 @@ export type ScopeTypeId = typeof ScopeTypeId;
  * @tsplus companion fncts.io.ScopeOps
  */
 export declare abstract class Scope {
-    readonly _typeId: ScopeTypeId;
+    readonly [ScopeTypeId]: ScopeTypeId;
     abstract addFinalizerExit(finalizer: Finalizer): UIO<void>;
     abstract fork: UIO<Scope.Closeable>;
 }

package/ScopedRef/definition.d.ts

@@ -7,7 +7,7 @@ export type ScopedRefTypeId = typeof ScopedRefTypeId;
  * @tsplus companion fncts.io.ScopedRefOps
  */
 export declare abstract class ScopedRef<A> {
-    readonly _typeId: ScopedRefTypeId;
+    readonly [ScopedRefTypeId]: ScopedRefTypeId;
     abstract set<R, E>(acquire: IO<R | Scope, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void>;
     abstract get: UIO<A>;
 }

package/State/api.d.ts

@@ -6,7 +6,7 @@ import type { State } from "./definition.js";
  * @tsplus getter fncts.io.State get
  * @tsplus location "@fncts/io/State/api"
  */
-export declare function get_<S>(self: State<S>, __tsplusTrace?: string): UIO<S>;
+export declare function get<S>(self: State<S>, __tsplusTrace?: string): UIO<S>;
 /**
  * @tsplus static fncts.io.StateOps initial
  * @tsplus location "@fncts/io/State/api"

package/State/definition.d.ts

@@ -1,12 +1,15 @@
 import type { StateInternal } from "./internal.js";
+import { StateVariance } from "./internal.js";
 import { StateTypeId } from "./internal.js";
 /**
  * @tsplus type fncts.io.State
  * @tsplus companion fncts.io.StateOps
  */
 export declare abstract class State<S> {
-    readonly _A: () => S;
-    readonly _typeId: StateTypeId;
+    readonly [StateTypeId]: StateTypeId;
+    [StateVariance]: {
+        readonly _S: (_: S) => S;
+    };
 }
 /**
  * @tsplus macro remove

package/State/internal.d.ts

@@ -1,9 +1,13 @@
 import { UIO } from "@fncts/io/IO/definition";
+export declare const StateVariance: unique symbol;
+export type StateVariance = typeof StateVariance;
 export declare const StateTypeId: unique symbol;
 export type StateTypeId = typeof StateTypeId;
 export declare abstract class StateInternal<S> {
-    _A: () => S;
-    readonly _typeId: StateTypeId;
+    readonly [StateTypeId]: StateTypeId;
+    [StateVariance]: {
+        readonly _S: (_: S) => S;
+    };
     abstract get: UIO<S>;
     abstract set(s: S, __tsplusTrace?: string): UIO<void>;
     abstract update(f: (s: S) => S, __tsplusTrace?: string): UIO<void>;

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;