@fncts/io 0.0.21 → 0.0.23

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/api.d.ts

@@ -1,5 +1,6 @@
 import { IO, URIO, UIO } from "@fncts/io/IO/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
@@ -18,12 +19,12 @@ export declare function make<State, Env, In, Out>(initial: State, step: (now: nu
  * @tsplus pipeable fncts.io.Schedule addDelay
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function addDelay<Out>(f: (out: Out) => number, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out>;
+export declare function addDelay<Out>(f: (out: Out) => Duration, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out>;
 /**
  * @tsplus pipeable fncts.io.Schedule addDelayIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, number>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
+export declare function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
 /**
  * @tsplus pipeable fncts.io.Schedule andThen
  * @tsplus location "@fncts/io/Schedule/api"
@@ -39,6 +40,11 @@ export declare function andThenEither<State1, Env1, In1, Out1>(that: Schedule.Wi
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function as<Out2>(out2: Lazy<Out2>, __tsplusTrace?: string): <State, Env, In, Out>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out2>;
+/**
+ * @tsplus getter fncts.io.Schedule asUnit
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function asUnit<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>): Schedule.WithState<State, Env, In, void>;
 /**
  * @tsplus pipeable fncts.io.Schedule check
  * @tsplus location "@fncts/io/Schedule/api"
@@ -73,17 +79,17 @@ export declare function contramapIO<I, R1, I2>(f: (inp: I2) => URIO<R1, I>, __ts
  * @tsplus static fncts.io.ScheduleOps delayed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, number>, __tsplusTrace?: string): Schedule.WithState<S, R, I, number>;
+export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, Duration>, __tsplusTrace?: string): Schedule.WithState<S, R, I, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule delayed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayedSelf(f: (delay: number) => number, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
+export declare function delayedSelf(f: (delay: Duration) => Duration, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule delayedIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayedIO<R1>(f: (delay: number) => URIO<R1, number>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function delayedIO<R1>(f: (delay: Duration) => URIO<R1, Duration>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
  * @tsplus getter fncts.io.Schedule delays
  * @tsplus location "@fncts/io/Schedule/api"
@@ -103,7 +109,7 @@ export declare function dimapIO<I, O, R1, I2, R2, O2>(f: (inp2: I2) => URIO<R1,
  * @tsplus static fncts.io.ScheduleOps duration
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function duration(duration: number, __tsplusTrace?: string): Schedule.WithState<boolean, never, unknown, number>;
+export declare function duration(duration: Duration, __tsplusTrace?: string): Schedule.WithState<boolean, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule either
  * @tsplus pipeable-operator fncts.io.Schedule ||
@@ -119,7 +125,7 @@ export declare function eitherWith<O, S1, R1, I1, O1, O2>(that: Schedule.WithSta
  * @tsplus static fncts.io.ScheduleOps elapsed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, number>;
+export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule ensuring
  * @tsplus location "@fncts/io/Schedule/api"
@@ -129,7 +135,7 @@ export declare function ensuring(finalizer: UIO<any>, __tsplusTrace?: string): <
  * @tsplus static fncts.io.ScheduleOps exponential
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function exponential(base: number, factor?: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function exponential(base: Duration, factor?: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration>;
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
  * repetitions of the schedule so far.
@@ -144,7 +150,7 @@ export declare function exponential(base: number, factor?: number, __tsplusTrace
  * @tsplus static fncts.io.ScheduleOps fixed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function fixed(interval: number, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
+export declare function fixed(interval: Duration, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
 /**
  * @tsplus pipeable fncts.io.Schedule fold
  * @tsplus location "@fncts/io/Schedule/api"
@@ -179,7 +185,7 @@ export declare function intersectWith<S1, R1, I1, O1>(that: Schedule.WithState<S
  * @tsplus static fncts.io.Schedule linear
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function linear(base: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function linear(base: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule map
  * @tsplus location "@fncts/io/Schedule/api"
@@ -194,7 +200,17 @@ export declare function mapIO<Out, Env1, Out1>(f: (out: Out) => URIO<Env1, Out1>
  * @tsplus pipeable fncts.io.Schedule modifyDelayIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function modifyDelayIO<Out, Env1>(f: (out: Out, duration: number) => URIO<Env1, number>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
+export declare function modifyDelayIO<Out, Env1>(f: (out: Out, duration: Duration) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
+/**
+ * @tsplus static fncts.io.ScheduleOps once
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare const once: Schedule.WithState<number, never, any, void>;
+/**
+ * @tsplus static fncts.io.ScheduleOps asap
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare const asap: import("./definition.js").Schedule.WithState<number, never, any, void>;
 /**
  * @tsplus pipeable fncts.io.Schedule onDecision
  * @tsplus location "@fncts/io/Schedule/api"
@@ -216,17 +232,17 @@ export declare function reconsider<S, O, O2>(f: (state: S, out: O, decision: Dec
  */
 export declare function reconsiderIO<S, O, R1, O1>(f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>, __tsplusTrace?: string): <R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O1>;
 /**
- * @tsplus static fncts.io.Schedule recurs
+ * @tsplus static fncts.io.ScheduleOps recurs
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurs(n: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
- * @tsplus static fncts.io.Schedule recurWhile
+ * @tsplus static fncts.io.ScheduleOps recurWhile
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
- * @tsplus static fncts.io.Schedule recurWhileIO
+ * @tsplus static fncts.io.ScheduleOps recurWhileIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>, __tsplusTrace?: string): Schedule.WithState<void, R, A, A>;
@@ -259,7 +275,7 @@ export declare function repetitions<S, R, I, O>(self: Schedule.WithState<S, R, I
  * @tsplus pipeable fncts.io.Schedule resetAfter
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function resetAfter(duration: number, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, import("@fncts/base/data/Maybe.js").Maybe<number>], R, I, O>;
+export declare function resetAfter(duration: Duration, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, import("@fncts/base/data/Maybe.js").Maybe<number>], R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule resetWhen
  * @tsplus location "@fncts/io/Schedule/api"
@@ -274,7 +290,7 @@ export declare function run<I>(now: number, input: Iterable<I>, __tsplusTrace?:
  * @tsplus static fncts.io.Schedule spaced
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function spaced(duration: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function spaced(duration: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus static fncts.io.Schedule succeed
  * @tsplus location "@fncts/io/Schedule/api"
@@ -324,7 +340,7 @@ export declare function untilOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, _
  * @tsplus static fncts.io.Schedule upTo
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function upTo(duration: number, __tsplusTrace?: string): Schedule.WithState<Maybe<number>, never, unknown, number>;
+export declare function upTo(duration: Duration, __tsplusTrace?: string): Schedule.WithState<Maybe<number>, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule whileInput
  * @tsplus location "@fncts/io/Schedule/api"

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

@@ -3,7 +3,7 @@ import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype } from "@fncts/base/data/Newtype";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 export declare class Exited {
     readonly nextKey: number;
     readonly exit: Exit<any, any>;

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/api.d.ts

@@ -1,7 +1,7 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus static fncts.io.ScopedRefOps fromAcquire

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/Sink/api.d.ts

@@ -9,37 +9,37 @@ import { Cause } from "@fncts/base/data/Cause/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Enqueue } from "@fncts/io/Queue/definition";
+import { Queue } from "@fncts/io/Queue/definition";
 import { Hub } from "@fncts/io/Hub/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Duration } from "@fncts/base/data/Duration/definition";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 /**
  * Like {@link zip }, but keeps only the result from this sink
- * @tsplus pipeable fncts.io.Sink apFirst
+ * @tsplus pipeable fncts.io.Sink zipLeft
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirst<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
+export declare function zipLeft<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
 /**
  * Like {@link zipC }, but keeps only the result from this sink
- * @tsplus pipeable fncts.io.Sink apFirstC
+ * @tsplus pipeable fncts.io.Sink zipLeftC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirstC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
+export declare function zipLeftC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
 /**
  * Like {@link zip }, but keeps only the result from the `that` sink
- * @tsplus pipeable fncts.io.Sink apSecond
+ * @tsplus pipeable fncts.io.Sink zipRight
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecond<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
+export declare function zipRight<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
 /**
  * Like {@link zipC }, but keeps only the result from the `that` sink
- * @tsplus pipeable fncts.io.Sink apSecondC
+ * @tsplus pipeable fncts.io.Sink zipRightC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecondC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
+export declare function zipRightC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
 /**
  * Replaces this sink's result with the provided value.
  * @tsplus pipeable fncts.io.Sink as
@@ -252,14 +252,14 @@ export declare function fromPush<R, E, In, L, Z, R1>(push: IO<R, never, (_: Mayb
  * @tsplus static fncts.io.SinkOps fromQueue
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueue<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
+export declare function fromQueue<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which enqueues each element into the specified queue. The
  * queue will be shutdown once the stream is closed.
  * @tsplus static fncts.io.SinkOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueueWithShutdown<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
+export declare function fromQueueWithShutdown<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which publishes each element to the specified hub.
  * @tsplus static fncts.io.SinkOps fromHub

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>;