@fncts/io 0.0.22 → 0.0.24

package/Cached/definition.d.ts

@@ -1,5 +1,5 @@
 import type { CachedInternal } from "@fncts/io/Cached/internal";
-import { CachedTypeId } from "@fncts/io/Cached/internal";
+import { CachedTypeId, CachedVariance } from "@fncts/io/Cached/internal";
 /**
  * A Cached is a possibly resourceful value that is loaded into memory, and
  * which can be refreshed either manually or automatically
@@ -8,9 +8,11 @@ import { CachedTypeId } from "@fncts/io/Cached/internal";
  * @tsplus companion fncts.io.CachedOps
  */
 export declare class Cached<Error, Resource> {
-    readonly _E: () => Error;
-    readonly _A: () => Resource;
-    readonly _typeId: CachedTypeId;
+    readonly [CachedTypeId]: CachedTypeId;
+    [CachedVariance]: {
+        readonly _E: (_: never) => Error;
+        readonly _A: (_: never) => Resource;
+    };
 }
 /**
  * @tsplus macro remove

package/Cached/internal.d.ts

@@ -1,10 +1,10 @@
+import { Cached } from "@fncts/io/Cached/definition";
 import { FIO } from "@fncts/io/IO/definition";
+export declare const CachedVariance: unique symbol;
+export type CachedVariance = typeof CachedVariance;
 export declare const CachedTypeId: unique symbol;
 export type CachedTypeId = typeof CachedTypeId;
-export declare abstract class CachedInternal<Error, Resource> {
-    readonly _E: () => Error;
-    readonly _A: () => Resource;
-    readonly _typeId: CachedTypeId;
+export declare abstract class CachedInternal<Error, Resource> extends Cached<Error, Resource> {
     abstract get: FIO<Error, Resource>;
     abstract refresh: FIO<Error, void>;
 }

package/Channel/api.d.ts

@@ -49,16 +49,16 @@ export declare function acquireReleaseWith<Env, InErr, InElem, InDone, OutErr, O
 export declare function acquireReleaseExitWith<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone, Acquired>(acquire: IO<Env, OutErr, Acquired>, use: (a: Acquired) => Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone>, release: (a: Acquired, exit: Exit<OutErr, OutDone>) => URIO<Env, any>): Channel<Env, InErr, InElem, InDone, OutErr, OutElem1, OutDone>;
 /**
  * Construct a resource Channel with Acquire / Release
- * @tsplus static fncts.io.ChannelOps acquireReleaseOut
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutWith
  * @tsplus location "@fncts/io/Channel/api"
  */
-export declare function acquireReleaseOut<Env, OutErr, Acquired, Z>(acquire: IO<Env, OutErr, Acquired>, release: (a: Acquired) => URIO<Env, Z>): Channel<Env, unknown, unknown, unknown, OutErr, Acquired, void>;
+export declare function acquireReleaseOutWith<Env, OutErr, Acquired, Z>(acquire: IO<Env, OutErr, Acquired>, release: (a: Acquired) => URIO<Env, Z>): Channel<Env, unknown, unknown, unknown, OutErr, Acquired, void>;
 /**
  * Construct a resource Channel with Acquire / Release
- * @tsplus static fncts.io.ChannelOps acquireReleaseOutExit
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutExitWith
  * @tsplus location "@fncts/io/Channel/api"
  */
-export declare function acquireReleaseOutExit<R, R2, E, Z>(self: IO<R, E, Z>, release: (z: Z, e: Exit<unknown, unknown>) => URIO<R2, unknown>): Channel<R | R2, unknown, unknown, unknown, E, Z, void>;
+export declare function acquireReleaseOutExitWith<R, R2, E, Z>(self: IO<R, E, Z>, release: (z: Z, e: Exit<unknown, unknown>) => URIO<R2, unknown>): Channel<R | R2, unknown, unknown, unknown, E, Z, void>;
 /**
  * Creates a channel backed by a buffer. When the buffer is empty, the channel will simply
  * passthrough its input as output. However, when the buffer is non-empty, the value inside

package/Channel/definition.d.ts

@@ -23,18 +23,25 @@ export declare const enum ChannelTag {
     BracketOut = "BracketOut",
     Provide = "Provide"
 }
+export declare const ChannelVariance: unique symbol;
+export type ChannelVariance = typeof ChannelVariance;
+export declare const ChannelTypeId: unique symbol;
+export type ChannelTypeId = typeof ChannelTypeId;
 /**
  * @tsplus type fncts.io.Channel
  * @tsplus companion fncts.io.ChannelOps
  */
 export declare abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-    _Env: () => Env;
-    _InErr: (_: InErr) => void;
-    _InElem: (_: InElem) => void;
-    _InDone: (_: InDone) => void;
-    _OutErr: () => OutErr;
-    _OutElem: () => OutElem;
-    _OutDone: () => OutDone;
+    readonly [ChannelTypeId]: ChannelTypeId;
+    [ChannelVariance]: {
+        _Env: () => Env;
+        _InErr: (_: InErr) => void;
+        _InElem: (_: InElem) => void;
+        _InDone: (_: InDone) => void;
+        _OutErr: () => OutErr;
+        _OutElem: () => OutElem;
+        _OutDone: () => OutDone;
+    };
 }
 /**
  * @tsplus unify fncts.io.Channel
@@ -43,43 +50,57 @@ export declare function unifyChannel<X extends Channel<any, any, any, any, any,
     X
 ] extends [
     {
-        _Env: () => infer Env;
+        [ChannelVariance]: {
+            _Env: () => infer Env;
+        };
     }
 ] ? Env : never, [
     X
 ] extends [
     {
-        _InErr: (_: infer InErr) => void;
+        [ChannelVariance]: {
+            _InErr: (_: infer InErr) => void;
+        };
     }
 ] ? InErr : never, [
     X
 ] extends [
     {
-        _InElem: (_: infer InElem) => void;
+        [ChannelVariance]: {
+            _InElem: (_: infer InElem) => void;
+        };
     }
 ] ? InElem : never, [
     X
 ] extends [
     {
-        _InDone: (_: infer InDone) => void;
+        [ChannelVariance]: {
+            _InDone: (_: infer InDone) => void;
+        };
     }
 ] ? InDone : never, [
     X
 ] extends [
     {
-        _OutErr: () => infer OutErr;
+        [ChannelVariance]: {
+            _OutErr: () => infer OutErr;
+        };
     }
 ] ? OutErr : never, [
     X
 ] extends [
     {
-        _OutElem: () => infer OutElem;
+        [ChannelVariance]: {
+            _OutElem: () => infer OutElem;
+        };
     }
 ] ? OutElem : never, [
     X
 ] extends [
     {
-        _OutDone: () => infer OutDone;
+        [ChannelVariance]: {
+            _OutDone: () => infer OutDone;
+        };
     }
 ] ? OutDone : never>;
 export declare abstract class Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {

package/Channel/internal/ChannelExecutor.d.ts

@@ -47,6 +47,7 @@ export declare class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem
     private doneSucceed;
     private doneHalt;
     private addFinalizer;
+    private provide;
     private runBracketOut;
     private runEnsuring;
 }

package/Channel/internal/MergeDecision.d.ts

@@ -4,6 +4,8 @@ export declare const enum MergeDecisionTag {
     Done = "Done",
     Await = "Await"
 }
+export declare const MergeDecisionVariance: unique symbol;
+export type MergeDecisionVariance = typeof MergeDecisionVariance;
 export declare const MergeDecisionTypeId: unique symbol;
 export type MergeDecisionTypeId = typeof MergeDecisionTypeId;
 /**
@@ -11,12 +13,14 @@ export type MergeDecisionTypeId = typeof MergeDecisionTypeId;
  * @tsplus companion fncts.io.Channel.MergeDecisionOps
  */
 export declare abstract class MergeDecision<R, E0, Z0, E, Z> {
-    readonly _typeId: MergeDecisionTypeId;
-    readonly _R: () => R;
-    readonly _E0: (_: E0) => void;
-    readonly _Z0: (_: Z0) => void;
-    readonly _E: () => E;
-    readonly _Z: () => Z;
+    readonly [MergeDecisionTypeId]: MergeDecisionTypeId;
+    [MergeDecisionVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E0: (_: E0) => void;
+        readonly _Z0: (_: Z0) => void;
+        readonly _E: (_: never) => E;
+        readonly _Z: (_: never) => Z;
+    };
 }
 /**
  * @tsplus unify fncts.io.Channel.MergeDecision

package/CountdownLatch.d.ts

@@ -10,7 +10,7 @@ export type CountdownLatchTypeId = typeof CountdownLatchTypeId;
 export declare class CountdownLatch {
     private _count;
     private _waiters;
-    readonly _typeId: CountdownLatchTypeId;
+    readonly [CountdownLatchTypeId]: CountdownLatchTypeId;
     constructor(_count: Ref<number>, _waiters: Future<never, void>);
     readonly await: UIO<void>;
     readonly countDown: UIO<void>;

package/Differ/definition.d.ts

@@ -4,10 +4,8 @@ export type DifferTypeId = typeof DifferTypeId;
  * @tsplus type fncts.io.Differ
  * @tsplus companion fncts.io.DifferOps
  */
-export declare abstract class Differ<Value, Patch> {
-    readonly _typeId: DifferTypeId;
-    _Value: Value;
-    _Patch: Patch;
+export declare abstract class Differ<in out Value, in out Patch> {
+    readonly [DifferTypeId]: DifferTypeId;
     abstract readonly empty: Patch;
     abstract combine(first: Patch, second: Patch): Patch;
     abstract diff(oldValue: Value, newValue: Value): Patch;

package/Fiber/FiberRuntime.d.ts

@@ -20,22 +20,19 @@ import type { FiberStatus } from "../FiberStatus.js";
 import type { OnFailure, OnSuccess, OnSuccessAndFailure, UIO } from "../IO/definition.js";
 import type { RuntimeFlags } from "../RuntimeFlags.js";
 import { Trace } from "@fncts/base/data/Trace";
-import { FiberTypeId } from "@fncts/io/Fiber/definition";
+import { FiberTypeId, FiberVariance } from "@fncts/io/Fiber/definition";
 import { WhileLoop } from "../IO/definition.js";
+import { IOOpCode } from "../IO/definition.js";
 import { FiberMessage } from "./FiberMessage.js";
-declare const enum ContinuationTag {
-    RevertFlags = "RevertFlags",
-    UpdateTrace = "UpdateTrace"
-}
 export declare class RevertFlags {
     readonly patch: RuntimeFlags.Patch;
     readonly trace?: string | undefined;
-    readonly _tag = ContinuationTag.RevertFlags;
+    readonly ioOpCode = IOOpCode.RevertFlags;
     constructor(patch: RuntimeFlags.Patch, trace?: string | undefined);
 }
 export declare class UpdateTrace {
     readonly trace?: string | undefined;
-    readonly _tag = ContinuationTag.UpdateTrace;
+    readonly ioOpCode = IOOpCode.UpdateTrace;
     constructor(trace?: string | undefined);
 }
 export type Continuation = OnSuccess<any, any, any, any, any, any> | OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | WhileLoop<any, any, any> | UpdateTrace | RevertFlags;
@@ -45,9 +42,11 @@ export type Continuation = OnSuccess<any, any, any, any, any, any> | OnSuccessAn
 export declare class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     readonly fiberId: FiberId.Runtime;
     readonly runtimeFlags0: RuntimeFlags;
-    readonly _E: () => E;
-    readonly _A: () => A;
-    readonly _typeId: FiberTypeId;
+    readonly [FiberTypeId]: FiberTypeId;
+    [FiberVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
     readonly _tag = "RuntimeFiber";
     constructor(fiberId: FiberId.Runtime, fiberRefs0: FiberRefs, runtimeFlags0: RuntimeFlags);
     private _fiberRefs;
@@ -113,4 +112,3 @@ export declare class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
     getNextFailCont(): OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | RevertFlags | UpdateTrace | undefined;
     isFatal(t: unknown): boolean;
 }
-export {};

package/Fiber/definition.d.ts

@@ -7,15 +7,19 @@ import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
 import type { UIO } from "@fncts/io/IO/definition";
 import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
+export declare const FiberVariance: unique symbol;
+export type FiberVariance = typeof FiberVariance;
 export declare const FiberTypeId: unique symbol;
 export type FiberTypeId = typeof FiberTypeId;
 /**
  * @tsplus type fncts.io.Fiber
  */
 export interface Fiber<E, A> {
-    readonly _typeId: FiberTypeId;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [FiberTypeId]: FiberTypeId;
+    readonly [FiberVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
 }
 /**
  * @tsplus type fncts.io.FiberOps
@@ -80,9 +84,11 @@ export declare class SyntheticFiber<E, A> implements FiberCommon<E, A> {
     readonly poll: UIO<Maybe<Exit<E, A>>>;
     readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     readonly _tag = "SyntheticFiber";
-    readonly _typeId: FiberTypeId;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [FiberTypeId]: FiberTypeId;
+    [FiberVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
     readonly await: UIO<import("@fncts/base/data/Exit").Exit<E, A>>;
     constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritAll: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAsFork: (fiberId: FiberId) => UIO<void>);
 }

package/FiberRef/definition.d.ts

@@ -1,5 +1,7 @@
 import { Hashable } from "@fncts/base/data/Hashable";
 import { Equatable } from "@fncts/base/data/Equatable";
+export declare const FiberRefVariance: unique symbol;
+export type FiberRefVariance = typeof FiberRefVariance;
 export declare const FiberRefTypeId: unique symbol;
 export type FiberRefTypeId = typeof FiberRefTypeId;
 /**
@@ -7,8 +9,10 @@ export type FiberRefTypeId = typeof FiberRefTypeId;
  * @tsplus companion fncts.io.FiberRefOps
  */
 export declare abstract class FiberRef<Value> {
-    readonly _typeId: FiberRefTypeId;
-    readonly _A: () => Value;
+    readonly [FiberRefTypeId]: FiberRefTypeId;
+    [FiberRefVariance]: {
+        readonly _Value: (_: Value) => Value;
+    };
     readonly _Patch: unknown;
 }
 export declare namespace FiberRef {

package/FiberRefs/api.d.ts

@@ -46,4 +46,4 @@ export declare function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberR
  * @tsplus macro identity
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
-export declare function unFiberRefs(self: FiberRefs): HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
+export declare function unFiberRefs(self: FiberRefs): HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>;

package/FiberRefs/definition.d.ts

@@ -12,7 +12,7 @@ export interface FiberRefsN extends HKT {
  */
 export interface FiberRefs extends Newtype<{
     readonly FiberRefs: unique symbol;
-}, HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>> {
+}, HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>> {
 }
 /**
  * @tsplus type fncts.io.FiberRefsOps

package/Hub/definition.d.ts

@@ -2,7 +2,9 @@ import { UIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import type { IO } from "@fncts/io/IO";
 import type { PDequeue, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue";
-import { EnqueueTypeId, QueueTypeId } from "@fncts/io/Queue";
+import { EnqueueTypeId, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
+export declare const HubVariance: unique symbol;
+export type HubVariance = typeof HubVariance;
 export declare const HubTypeId: unique symbol;
 export type HubTypeId = typeof HubTypeId;
 /**
@@ -16,13 +18,15 @@ export type HubTypeId = typeof HubTypeId;
  * @tsplus type fncts.io.Hub
  */
 export interface PHub<RA, RB, EA, EB, A, B> extends PEnqueue<RA, RB, EA, EB, A, B> {
-    readonly _typeId: HubTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+    readonly [HubTypeId]: HubTypeId;
+    readonly [HubVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
 }
 /**
  * @tsplus type fncts.io.Hub
@@ -40,13 +44,23 @@ export declare namespace Hub { }
 export declare abstract class PHubInternal<RA, RB, EA, EB, A, B> implements PHub<RA, RB, EA, EB, A, B>, PEnqueueInternal<RA, RB, EA, EB, A, B> {
     readonly [QueueTypeId]: QueueTypeId;
     readonly [EnqueueTypeId]: EnqueueTypeId;
-    _typeId: HubTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+    readonly [HubTypeId]: HubTypeId;
+    [HubVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
     /**
      * Waits for the hub to be shut down.
      */

package/IO/api/descriptor.d.ts

@@ -0,0 +1,12 @@
+import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
+import { IO, UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.IOOps descriptorWith
+ * @tsplus location "@fncts/io/IO/api/descriptor"
+ */
+export declare function descriptorWith<R, E, A>(f: (descriptor: FiberDescriptor) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps descriptor
+ * @tsplus location "@fncts/io/IO/api/descriptor"
+ */
+export declare const descriptor: UIO<FiberDescriptor>;

package/IO/api/interrupt.d.ts

@@ -1,8 +1,12 @@
+import { IO, FIO } from "@fncts/io/IO/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { FIO, IO } from "@fncts/io/IO/definition";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
-import { InterruptStatus } from "@fncts/io/InterruptStatus";
+import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+import { Exit } from "@fncts/base/data/Exit/definition";
+export interface InterruptibilityRestorer {
+    readonly restore: <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
+    readonly force: <R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string) => IO<R, E, A>;
+}
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
  * @tsplus static fncts.io.IOOps interruptAs
@@ -50,7 +54,7 @@ export declare function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrac
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A>;
+export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptibilityRestorer) => IO<R, E, A>): IO<R, E, A>;
 /**
  * @tsplus pipeable fncts.io.IO ensuring
  * @tsplus location "@fncts/io/IO/api/interrupt"
@@ -63,21 +67,26 @@ export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrac
  * @tsplus static fncts.io.IOOps interruptibleMask
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function interruptibleMask<R, E, A>(k: (restore: InterruptStatusRestore) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function interruptibleMask<R, E, A>(k: (restore: InterruptibilityRestorer) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted.
- * @tsplus fluent fncts.io.IO onInterrupt
+ * @tsplus pipeable fncts.io.IO onInterrupt
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterrupt_<R, E, A, R1>(ma: IO<R, E, A>, cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1, E, A>;
+export declare function onInterrupt<R1, E1>(cleanup: Lazy<IO<R1, E1, any>>, __tsplusTrace?: string): <R, E, A>(ma: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E1 | E, A>;
 /**
  * Calls the specified function, and runs the effect it returns, if this
- * effect is interrupted (allows for expanding error).
- * @tsplus fluent fncts.io.IO onInterruptExtended
+ * effect is interrupted.
+ * @tsplus pipeable fncts.io.IO onInterrupt
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function onInterruptWith<R1, E1>(cleanup: (interruptors: HashSet<FiberId>) => IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(ma: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E1 | E, A>;
+/**
+ * @tsplus pipeable fncts.io.IO onExit
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterruptExtended_<R, E, A, R2, E2>(self: IO<R, E, A>, cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string): IO<R | R2, E | E2, A>;
+export declare function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string): <R>(self: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E | E1, A>;
 /**
  * Returns an IO whose interruption will be disconnected from the
  * fiber's own interruption, being performed in the background without
@@ -94,12 +103,3 @@ export declare function onInterruptExtended_<R, E, A, R2, E2>(self: IO<R, E, A>,
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
 export declare function disconnect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Used to restore the inherited interruptibility
- */
-export declare class InterruptStatusRestore {
-    readonly flag: InterruptStatus;
-    constructor(flag: InterruptStatus);
-    restore: <R, E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R, E, A>;
-    force: <R, E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R, E, A>;
-}

package/IO/api/onTermination.d.ts

@@ -1,7 +1,6 @@
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { URIO, IO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
-import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus pipeable fncts.io.IO onTermination
  * @tsplus location "@fncts/io/IO/api/onTermination"

package/IO/api/sequenceT.d.ts

@@ -1,10 +1,26 @@
 import { ReadonlyNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { IO } from "@fncts/io/IO/definition";
-import type { _A, _E, _R } from "@fncts/base/types";
+import type { IOVariance } from "@fncts/io/IO/definition";
 /**
  * @tsplus static fncts.io.IOOps sequenceT
  * @tsplus location "@fncts/io/IO/api/sequenceT"
  */
-export declare function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(...ios: T): IO<_R<T[number]>, _E<T[number]>, {
-    [K in keyof T]: _A<T[K]>;
+export declare function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(...ios: T): IO<[
+    T[number]
+] extends [{
+    [IOVariance]: {
+        _R: () => infer R;
+    };
+}] ? R : never, [
+    T[number]
+] extends [{
+    [IOVariance]: {
+        _E: () => infer E;
+    };
+}] ? E : never, {
+    [K in keyof T]: T[K] extends {
+        [IOVariance]: {
+            _A: () => infer A;
+        };
+    } ? A : never;
 }>;

package/IO/api.d.ts

@@ -264,6 +264,11 @@ export declare function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, _
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare const fiberId: IO<never, never, FiberId>;
+/**
+ * @tsplus static fncts.io.IOOps fiberIdWith
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function fiberIdWith<R, E, A>(f: (id: FiberId.Runtime) => IO<R, E, A>): IO<R, E, A>;
 /**
  * Filters the collection using the specified effectual predicate.
  * @tsplus static fncts.io.IOOps filter