@fncts/io 0.0.22 → 0.0.23

package/_src/FiberRefs/api.ts

@@ -81,6 +81,6 @@ export function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberRefs {
  * @tsplus getter fncts.io.FiberRefs unFiberRefs
  * @tsplus macro identity
  */
-export function unFiberRefs(self: FiberRefs): HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>> {
+export function unFiberRefs(self: FiberRefs): HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>> {
   return FiberRefs.reverseGet(self);
 }

package/_src/FiberRefs/definition.ts

@@ -8,7 +8,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]>>
   > {}
 
 /**

package/_src/Future/api.ts

@@ -194,17 +194,26 @@ export function unsafeSucceed<A>(a: A, __tsplusTrace?: string) {
  * @tsplus getter fncts.io.Future await
  */
 export function wait<E, A>(future: Future<E, A>, __tsplusTrace?: string): IO<never, E, A> {
-  return IO.asyncInterrupt<never, E, A>((k) => {
+  return IO.defer(() => {
     switch (future.state._tag) {
       case FutureStateTag.Done: {
-        return Either.right(future.state.value);
+        return future.state.value;
       }
       case FutureStateTag.Pending: {
-        future.state = new Pending(future.state.joiners.prepend(k));
-        return Either.left(interruptJoiner(future, k));
+        return IO.asyncInterrupt<never, E, A>((k) => {
+          switch (future.state._tag) {
+            case FutureStateTag.Done: {
+              return Either.right(future.state.value);
+            }
+            case FutureStateTag.Pending: {
+              future.state = new Pending(future.state.joiners.prepend(k));
+              return Either.left(interruptJoiner(future, k));
+            }
+          }
+        }, future.blockingOn);
       }
     }
-  }, future.blockingOn);
+  });
 }
 
 function interruptJoiner<E, A>(

package/_src/Hub/api.ts

@@ -11,7 +11,7 @@ import {
   unsafeMakeHub,
 } from "@fncts/io/Hub/internal";
 import { Hub as HubInternal } from "@fncts/io/internal/Hub";
-import { EnqueueTypeId, QueueTypeId } from "@fncts/io/Queue";
+import { EnqueueTypeId, QueueTypeId , QueueVariance } from "@fncts/io/Queue";
 
 /**
  * Waits for the hub to be shut down.
@@ -275,12 +275,14 @@ export function mapIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?:
 class ToQueue<RA, RB, EA, EB, A, B> implements PEnqueue<RA, RB, EA, EB, A, B> {
   readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
   readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
-  declare _RA: () => RA;
-  declare _RB: () => RB;
-  declare _EA: () => EA;
-  declare _EB: () => EB;
-  declare _A: (_: A) => void;
-  declare _B: () => B;
+  declare [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;
+  };
   constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>) {}
   awaitShutdown = this.source.awaitShutdown;
   capacity      = this.source.capacity;

package/_src/Hub/definition.ts

@@ -1,7 +1,10 @@
 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 const HubVariance = Symbol.for("fncts.io.Hub.Variance");
+export type HubVariance = typeof HubVariance;
 
 export const HubTypeId = Symbol.for("fncts.io.Hub");
 export type HubTypeId = typeof HubTypeId;
@@ -17,13 +20,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;
+  };
 }
 
 /**
@@ -46,13 +51,23 @@ export abstract class PHubInternal<RA, RB, EA, EB, A, B>
 {
   readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
   readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
-  _typeId: HubTypeId = HubTypeId;
-  readonly _RA!: () => RA;
-  readonly _RB!: () => RB;
-  readonly _EA!: () => EA;
-  readonly _EB!: () => EB;
-  readonly _A!: (_: A) => void;
-  readonly _B!: () => B;
+  readonly [HubTypeId]: HubTypeId         = HubTypeId;
+  declare [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;
+  };
+  declare [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/_src/IO/api/interrupt.ts

@@ -2,6 +2,21 @@ import { Dynamic, Interruptible, Uninterruptible } from "@fncts/io/IO/definition
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 
+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>;
+}
+
+const RestoreInterruptible: InterruptibilityRestorer = {
+  restore: (io, __tsplusTrace) => io.interruptible,
+  force: (io, __tsplusTrace) => io.interruptible,
+};
+
+const RestoreUninterruptible: InterruptibilityRestorer = {
+  restore: (io, __tsplusTrace) => io.uninterruptible,
+  force: (io, __tsplusTrace) => io.uninterruptible.disconnect.interruptible,
+};
+
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
  *
@@ -51,7 +66,6 @@ export const interrupt: IO<never, never, never> = IO.fiberId.flatMap(IO.interrup
  */
 export function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return new Interruptible(self, __tsplusTrace);
-  // return self.setInterruptStatus(InterruptStatus.interruptible);
 }
 
 /**
@@ -67,7 +81,6 @@ export function interruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string
  */
 export function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return new Uninterruptible(self, __tsplusTrace);
-  // return self.setInterruptStatus(InterruptStatus.uninterruptible);
 }
 
 /**
@@ -77,9 +90,9 @@ export function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: stri
  *
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  */
-export function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A> {
+export function uninterruptibleMask<R, E, A>(f: (restore: InterruptibilityRestorer) => IO<R, E, A>): IO<R, E, A> {
   return new Dynamic(RuntimeFlags.disable(RuntimeFlag.Interruption), (oldFlags) =>
-    f(new InterruptStatusRestore(InterruptStatus.fromBoolean(oldFlags.interruption))),
+    f(oldFlags.interruption ? RestoreInterruptible : RestoreUninterruptible),
   );
 }
 
@@ -109,52 +122,72 @@ export function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: stri
  * @tsplus static fncts.io.IOOps interruptibleMask
  */
 export function interruptibleMask<R, E, A>(
-  k: (restore: InterruptStatusRestore) => IO<R, E, A>,
+  k: (restore: InterruptibilityRestorer) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return IO.checkInterruptible((flag) => k(new InterruptStatusRestore(flag)).interruptible);
+  return IO.checkInterruptible(
+    (flag) => k(flag.isInterruptible ? RestoreInterruptible : RestoreUninterruptible).interruptible,
+  );
 }
 
 /**
  * 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
  */
-export 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> {
-  return uninterruptibleMask(({ restore }) =>
-    restore(ma).matchCauseIO(
-      (cause) =>
-        cause.interrupted ? cleanup(cause.interruptors).zipRight(IO.failCauseNow(cause)) : IO.failCauseNow(cause),
-      IO.succeedNow,
-    ),
-  );
+export function onInterrupt<R1, E1>(cleanup: Lazy<IO<R1, E1, any>>, __tsplusTrace?: string) {
+  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return ma.onExit((exit) =>
+      exit.match(
+        (cause) => (cause.isInterruptedOnly ? cleanup() : IO.unit),
+        () => IO.unit,
+      ),
+    );
+  };
 }
 
 /**
  * Calls the specified function, and runs the effect it returns, if this
- * effect is interrupted (allows for expanding error).
+ * effect is interrupted.
  *
- * @tsplus fluent fncts.io.IO onInterruptExtended
+ * @tsplus pipeable fncts.io.IO onInterrupt
  */
-export function onInterruptExtended_<R, E, A, R2, E2>(
-  self: IO<R, E, A>,
-  cleanup: Lazy<IO<R2, E2, any>>,
+export function onInterruptWith<R1, E1>(
+  cleanup: (interruptors: HashSet<FiberId>) => IO<R1, E1, any>,
   __tsplusTrace?: string,
-): IO<R | R2, E | E2, A> {
-  return uninterruptibleMask(({ restore }) =>
-    restore(self).matchCauseIO(
-      (cause) =>
-        cause.interrupted
-          ? cleanup().matchCauseIO(IO.failCauseNow, () => IO.failCauseNow(cause))
-          : IO.failCauseNow(cause),
-      IO.succeedNow,
-    ),
-  );
+) {
+  return <R, E, A>(ma: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return ma.onExit((exit) =>
+      exit.match(
+        (cause) => (cause.isInterruptedOnly ? cleanup(cause.interruptors) : IO.unit),
+        () => IO.unit,
+      ),
+    );
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.IO onExit
+ */
+export function onExit<E, A, R1, E1>(cleanup: (exit: Exit<E, A>) => IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R>(self: IO<R, E, A>): IO<R | R1, E | E1, A> => {
+    return IO.uninterruptibleMask(({ restore }) =>
+      restore(self).matchCauseIO(
+        (failure1) => {
+          const result = Exit.failCause(failure1);
+          return cleanup(result).matchCauseIO(
+            (failure2) => IO.failCauseNow(Cause.then(failure1, failure2)),
+            () => IO.fromExitNow(result),
+          );
+        },
+        (success) => {
+          const result = Exit.succeed(success);
+          return cleanup(result) > IO.fromExitNow(result);
+        },
+      ),
+    );
+  };
 }
 
 /**
@@ -174,27 +207,11 @@ export function onInterruptExtended_<R, E, A, R2, E2>(
  */
 export function disconnect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
   return uninterruptibleMask(({ restore }) =>
-    IO.fiberId.flatMap((id) =>
-      restore(self).forkDaemon.flatMap((fiber) =>
-        restore(fiber.join).onInterrupt(() => fiber.interruptAs(id).forkDaemon),
-      ),
+    IO.fiberId.flatMap((fiberId) =>
+      Do((Δ) => {
+        const fiber = Δ(restore(self).forkDaemon);
+        return Δ(restore(fiber.join).onInterrupt(fiber.interruptAsFork(fiberId)));
+      }),
     ),
   );
 }
-
-/**
- * Used to restore the inherited interruptibility
- */
-export class InterruptStatusRestore {
-  constructor(readonly flag: InterruptStatus) {}
-
-  restore = <R, E, A>(io: IO<R, E, A>): IO<R, E, A> =>
-    this.flag.isInterruptible ? io.interruptible : io.uninterruptible;
-
-  force = <R, E, A>(io: IO<R, E, A>): IO<R, E, A> => {
-    if (this.flag.isUninteruptible) {
-      return io.uninterruptible.disconnect.interruptible;
-    }
-    return io.interruptible;
-  };
-}

package/_src/IO/api/onTermination.ts

@@ -3,13 +3,14 @@
  */
 export function onTermination<R1>(cleanup: (cause: Cause<never>) => URIO<R1, any>, __tsplusTrace?: string) {
   return <R, E, A>(self: Lazy<IO<R, E, A>>): IO<R | R1, E, A> => {
-    return IO.unit.bracketExit(
-      () => self(),
-      (_, exit: Exit<E, A>) =>
-        exit.match(
-          (cause) => cause.failureOrCause.match(() => IO.unit, cleanup),
-          () => IO.unit,
-        ),
+    return IO.defer(self).onExit((exit) =>
+      exit.match(
+        (cause) => {
+          if (cause.isFailure) return IO.unit;
+          else return cleanup(cause as Cause<never>);
+        },
+        () => IO.unit,
+      ),
     );
   };
 }

package/_src/IO/api/sequenceT.ts

@@ -1,4 +1,4 @@
-import type { _A, _E, _R } from "@fncts/base/types";
+import type { IOVariance } from "@fncts/io/IO/definition";
 
 import { identity, unsafeCoerce } from "@fncts/base/data/function";
 
@@ -8,11 +8,9 @@ import { identity, unsafeCoerce } from "@fncts/base/data/function";
 export 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]>;
-  }
+  [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 }
 > {
   return unsafeCoerce(IO.foreach(ios, identity));
 }

package/_src/IO/api.ts

@@ -410,6 +410,21 @@ export function deferTryCatch<R, E, A, E1>(
   });
 }
 
+/**
+ * @tsplus static fncts.io.IOOps descriptorWith
+ */
+export function descriptorWith<R, E, A>(f: (descriptor: FiberDescriptor) => IO<R, E, A>): IO<R, E, A> {
+  return IO.withFiberRuntime((fiber, status) => {
+    const descriptor = new FiberDescriptor(fiber.id, status, fiber.getFiberRef(FiberRef.interruptedCause).interruptors);
+    return f(descriptor);
+  });
+}
+
+/**
+ * @tsplus static fncts.io.IOOps descriptor
+ */
+export const descriptor: UIO<FiberDescriptor> = IO.descriptorWith((descriptor) => IO.succeedNow(descriptor));
+
 /**
  * Folds an `IO` that may fail with `E` or succeed with `A` into one that never fails but succeeds with `Either<E, A>`
  *
@@ -488,7 +503,14 @@ export function failCause<E = never, A = never>(cause: Lazy<Cause<E>>, __tsplusT
  *
  * @tsplus static fncts.io.IOOps fiberId
  */
-export const fiberId: IO<never, never, FiberId> = IO.withFiberRuntime((fiber) => IO.succeed(fiber.id));
+export const fiberId: IO<never, never, FiberId> = IO.fiberIdWith((id) => IO.succeedNow(id));
+
+/**
+ * @tsplus static fncts.io.IOOps fiberIdWith
+ */
+export function fiberIdWith<R, E, A>(f: (id: FiberId.Runtime) => IO<R, E, A>): IO<R, E, A> {
+  return IO.withFiberRuntime((fiber) => f(fiber.id));
+}
 
 /**
  * Filters the collection using the specified effectual predicate.

package/_src/IO/definition.ts

@@ -6,6 +6,9 @@ import type { Trace } from "@fncts/base/data/Trace";
 import { RuntimeFlag } from "../RuntimeFlag.js";
 import { RuntimeFlags } from "../RuntimeFlags.js";
 
+export const IOVariance = Symbol.for("fncts.io.IO.Variance");
+export type IOVariance = typeof IOVariance;
+
 export const IOTypeId = Symbol.for("fncts.io.IO");
 export type IOTypeId = typeof IOTypeId;
 
@@ -23,10 +26,12 @@ export interface IOF extends HKT {
  * @tsplus companion fncts.io.IOOps
  */
 export abstract class IO<R, E, A> {
-  readonly _typeId: IOTypeId = IOTypeId;
-  declare _R: () => R;
-  declare _E: () => E;
-  declare _A: () => A;
+  readonly [IOTypeId]: IOTypeId = IOTypeId;
+  declare [IOVariance]: {
+    _R: () => R;
+    _E: () => E;
+    _A: () => A;
+  };
 }
 
 /**
@@ -45,9 +50,9 @@ export const IOAspects: IOAspects = {};
 export function unifyIO<X extends IO<any, any, any>>(
   self: X,
 ): IO<
-  [X] extends [{ _R: () => infer R }] ? R : never,
-  [X] extends [{ _E: () => infer E }] ? E : never,
-  [X] extends [{ _A: () => infer A }] ? A : never
+  [X] extends [{ [IOVariance]: { _R: () => infer R } }] ? R : never,
+  [X] extends [{ [IOVariance]: { _E: () => infer E } }] ? E : never,
+  [X] extends [{ [IOVariance]: { _A: () => infer A } }] ? A : never
 > {
   return self;
 }
@@ -58,7 +63,7 @@ export type URIO<R, A> = IO<R, never, A>;
 
 export type FIO<E, A> = IO<never, E, A>;
 
-export const enum IOTag {
+export const enum IOOpCode {
   SucceedNow,
   Fail,
   Sync,
@@ -72,21 +77,24 @@ export const enum IOTag {
   Stateful,
   WhileLoop,
   YieldNow,
+  Commit,
+  RevertFlags,
+  UpdateTrace,
 }
 
 export function isIO(u: unknown): u is IO<any, any, any> {
-  return hasTypeId(u, IOTypeId);
+  return isObject(u) && IOTypeId in u;
 }
 
 export class Sync<A> extends IO<never, never, A> {
-  readonly _tag = IOTag.Sync;
+  readonly ioOpCode = IOOpCode.Sync;
   constructor(readonly evaluate: () => A, readonly trace?: string) {
     super();
   }
 }
 
 export class Async<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.Async;
+  readonly ioOpCode = IOOpCode.Async;
   constructor(
     readonly registerCallback: (f: (_: IO<R, E, A>) => void) => any,
     readonly blockingOn: () => FiberId,
@@ -100,7 +108,7 @@ export class Async<R, E, A> extends IO<R, E, A> {
  * @internal
  */
 export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R1 | R2, E1 | E2, B | C> {
-  readonly _tag = IOTag.OnSuccessAndFailure;
+  readonly ioOpCode = IOOpCode.OnSuccessAndFailure;
 
   constructor(
     readonly first: IO<R, E, A>,
@@ -120,7 +128,7 @@ export class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends IO<R | R
 }
 
 export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
-  readonly _tag = IOTag.OnFailure;
+  readonly ioOpCode = IOOpCode.OnFailure;
   constructor(
     readonly first: IO<R, E, A>,
     readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>,
@@ -141,7 +149,7 @@ export class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B> {
  * @internal
  */
 export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
-  readonly _tag = IOTag.OnSuccess;
+  readonly ioOpCode = IOOpCode.OnSuccess;
   constructor(readonly first: IO<R, E, A>, readonly successK: (a: A) => IO<R1, E1, A1>, readonly trace?: string) {
     super();
   }
@@ -157,21 +165,21 @@ export class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A1> {
  * @internal
  */
 export class SucceedNow<A> extends IO<never, never, A> {
-  readonly _tag = IOTag.SucceedNow;
+  readonly ioOpCode = IOOpCode.SucceedNow;
   constructor(readonly value: A, readonly trace?: string) {
     super();
   }
 }
 
 export class UpdateRuntimeFlags extends IO<never, never, void> {
-  readonly _tag = IOTag.UpdateRuntimeFlags;
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlags;
   constructor(readonly update: RuntimeFlags.Patch, readonly trace?: string) {
     super();
   }
 }
 
 export class Interruptible<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.UpdateRuntimeFlagsWithin;
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -183,7 +191,7 @@ export class Interruptible<R, E, A> extends IO<R, E, A> {
 }
 
 export class Uninterruptible<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.UpdateRuntimeFlagsWithin;
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(readonly effect: IO<R, E, A>, readonly trace?: string) {
     super();
   }
@@ -195,7 +203,7 @@ export class Uninterruptible<R, E, A> extends IO<R, E, A> {
 }
 
 export class Dynamic<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.UpdateRuntimeFlagsWithin;
+  readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
   constructor(
     readonly update: RuntimeFlagsPatch,
     readonly f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>,
@@ -210,21 +218,21 @@ export class Dynamic<R, E, A> extends IO<R, E, A> {
 }
 
 export class GenerateStackTrace extends IO<never, never, Trace> {
-  readonly _tag = IOTag.GenerateStackTrace;
+  readonly ioOpCode = IOOpCode.GenerateStackTrace;
   constructor(readonly trace?: string) {
     super();
   }
 }
 
 export class Stateful<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.Stateful;
+  readonly ioOpCode = IOOpCode.Stateful;
   constructor(readonly onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, readonly trace?: string) {
     super();
   }
 }
 
 export class WhileLoop<R, E, A> extends IO<R, E, void> {
-  readonly _tag = IOTag.WhileLoop;
+  readonly ioOpCode = IOOpCode.WhileLoop;
   constructor(
     readonly check: () => boolean,
     readonly body: () => IO<R, E, A>,
@@ -236,7 +244,7 @@ export class WhileLoop<R, E, A> extends IO<R, E, void> {
 }
 
 export class YieldNow extends IO<never, never, void> {
-  readonly _tag = IOTag.YieldNow;
+  readonly ioOpCode = IOOpCode.YieldNow;
   constructor(readonly trace?: string) {
     super();
   }
@@ -246,7 +254,7 @@ export class YieldNow extends IO<never, never, void> {
  * @internal
  */
 export class Fail<E> extends IO<never, E, never> {
-  readonly _tag = IOTag.Fail;
+  readonly ioOpCode = IOOpCode.Fail;
 
   constructor(readonly cause: Lazy<Cause<E>>, readonly trace?: string) {
     super();
@@ -266,7 +274,8 @@ export type Concrete =
   | Stateful<any, any, any>
   | WhileLoop<any, any, any>
   | YieldNow
-  | Fail<any>;
+  | Fail<any>
+  | STM<any, any, any>;
 
 /**
  * @tsplus static fncts.io.IOOps concrete
@@ -292,10 +301,10 @@ export const IOErrorTypeId = Symbol.for("fncts.io.IO.IOError");
 export type IOErrorTypeId = typeof IOErrorTypeId;
 
 export class IOError<E> {
-  readonly _typeId: IOErrorTypeId = IOErrorTypeId;
+  readonly [IOErrorTypeId]: IOErrorTypeId = IOErrorTypeId;
   constructor(readonly cause: Cause<E>) {}
 }
 
 export function isIOError(u: unknown): u is IOError<unknown> {
-  return hasTypeId(u, IOErrorTypeId);
+  return isObject(u) && IOErrorTypeId in u;
 }

package/_src/IO.ts

@@ -33,7 +33,6 @@ export * from "./IO/api/fulfill.js";
 export * from "./IO/api/interrupt.js";
 export * from "./IO/api/memoize.js";
 export * from "./IO/api/once.js";
-export * from "./IO/api/onExit.js";
 export * from "./IO/api/onTermination.js";
 export * from "./IO/api/provideLayer.js";
 export * from "./IO/api/provideSomeLayer.js";

package/_src/Layer/MemoMap.ts

@@ -162,7 +162,7 @@ export function scope(scope: Scope, __tsplusTrace?: string) {
               .zipWith(memoMap.getOrElseMemoize(scope, layer.that, layer.trace), layer.f, layer.trace),
         );
       }
-      case LayerTag.ZipWithC: {
+      case LayerTag.ZipWithConcurrent: {
         return IO.succeed(
           () => (memoMap: MemoMap) =>
             memoMap

package/_src/Layer/api.ts

@@ -1,7 +1,7 @@
 import type { Spreadable } from "@fncts/base/types";
 import type { Erase } from "@fncts/typelevel/Intersection";
 
-import { Fold, Fresh, FromScoped, Layer, To, ZipWithC } from "@fncts/io/Layer/definition";
+import { Fold, Fresh, FromScoped, Layer, To, ZipWithConcurrent } from "@fncts/io/Layer/definition";
 import { DecisionTag } from "@fncts/io/Schedule";
 
 /**
@@ -9,7 +9,7 @@ import { DecisionTag } from "@fncts/io/Schedule";
  */
 export function and<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string) {
   return <RIn, E, ROut>(self: Layer<RIn, E, ROut>): Layer<RIn | RIn1, E | E1, ROut | ROut1> => {
-    return new ZipWithC(self, that, (a, b) => a.union(b), __tsplusTrace);
+    return new ZipWithConcurrent(self, that, (a, b) => a.union(b), __tsplusTrace);
   };
 }