@fncts/io 0.0.22 → 0.0.23

package/_src/Cached/definition.ts

@@ -1,6 +1,6 @@
 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
@@ -10,9 +10,11 @@ import { CachedTypeId } from "@fncts/io/Cached/internal";
  * @tsplus companion fncts.io.CachedOps
  */
 export class Cached<Error, Resource> {
-  readonly _E!: () => Error;
-  readonly _A!: () => Resource;
-  readonly _typeId: CachedTypeId = CachedTypeId;
+  readonly [CachedTypeId]: CachedTypeId = CachedTypeId;
+  declare [CachedVariance]: {
+    readonly _E: (_: never) => Error;
+    readonly _A: (_: never) => Resource;
+  };
 }
 
 /**

package/_src/Cached/internal.ts

@@ -1,10 +1,10 @@
+export const CachedVariance = Symbol.for("fncts.io.Cached.Variance");
+export type CachedVariance = typeof CachedVariance;
+
 export const CachedTypeId = Symbol.for("fncts.io.Cached");
 export type CachedTypeId = typeof CachedTypeId;
 
-export abstract class CachedInternal<Error, Resource> {
-  readonly _E!: () => Error;
-  readonly _A!: () => Resource;
-  readonly _typeId: CachedTypeId = CachedTypeId;
+export abstract class CachedInternal<Error, Resource> extends Cached<Error, Resource> {
   abstract get: FIO<Error, Resource>;
   abstract refresh: FIO<Error, void>;
 }

package/_src/Channel/api.ts

@@ -83,21 +83,21 @@ export function acquireReleaseExitWith<Env, InErr, InElem, InDone, OutErr, OutEl
 /**
  * Construct a resource Channel with Acquire / Release
  *
- * @tsplus static fncts.io.ChannelOps acquireReleaseOut
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutWith
  */
-export function acquireReleaseOut<Env, OutErr, Acquired, Z>(
+export 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> {
-  return Channel.acquireReleaseOutExit(acquire, (z, _) => release(z));
+  return Channel.acquireReleaseOutExitWith(acquire, (z, _) => release(z));
 }
 
 /**
  * Construct a resource Channel with Acquire / Release
  *
- * @tsplus static fncts.io.ChannelOps acquireReleaseOutExit
+ * @tsplus static fncts.io.ChannelOps acquireReleaseOutExitWith
  */
-export function acquireReleaseOutExit<R, R2, E, Z>(
+export 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> {
@@ -752,17 +752,16 @@ export function interrupt(fiberId: FiberId): Channel<never, unknown, unknown, un
 export function scoped<R, E, A>(
   io: Lazy<IO<R, E, A>>,
 ): Channel<Exclude<R, Scope>, unknown, unknown, unknown, E, A, unknown> {
-  return Channel.acquireReleaseOutExit(
-    Scope.make.flatMap((scope) =>
-      IO.uninterruptibleMask(({ restore }) =>
-        restore(scope.extend(io)).matchCauseIO(
-          (cause) => scope.close(Exit.failCause(cause)) > IO.failCauseNow(cause),
-          (out) => IO.succeedNow(tuple(out, scope)),
+  return Channel.unwrap(
+    IO.uninterruptibleMask(({ restore }) =>
+      Scope.make.map((scope) =>
+        Channel.acquireReleaseOutExitWith(
+          restore(scope.extend(io)).tapErrorCause((cause) => scope.close(Exit.failCause(cause))),
+          (_, exit) => scope.close(exit),
         ),
       ),
     ),
-    ([_, scope], exit) => scope.close(exit),
-  ).mapOut(([a]) => a);
+  );
 }
 
 /**
@@ -1019,12 +1018,12 @@ export function pipeTo<OutErr, OutElem, OutDone, Env1, OutErr1, OutElem1, OutDon
 
 const ChannelFailureTypeId = Symbol.for("@principia/base/Channel/ChannelFailure");
 class ChannelFailure<E> {
-  readonly _typeId = ChannelFailureTypeId;
+  readonly [ChannelFailureTypeId] = ChannelFailureTypeId;
   constructor(readonly error: E) {}
 }
 
 function isChannelFailure<E>(u: unknown): u is ChannelFailure<E> {
-  return hasTypeId(u, ChannelFailureTypeId);
+  return isObject(u) && ChannelFailureTypeId in u;
 }
 
 /**

package/_src/Channel/definition.ts

@@ -21,18 +21,27 @@ export const enum ChannelTag {
   Provide = "Provide",
 }
 
+export const ChannelVariance = Symbol.for("fncts.io.Channel.Variance");
+export type ChannelVariance = typeof ChannelVariance;
+
+export const ChannelTypeId = Symbol.for("fncts.io.Channel");
+export type ChannelTypeId = typeof ChannelTypeId;
+
 /**
  * @tsplus type fncts.io.Channel
  * @tsplus companion fncts.io.ChannelOps
  */
 export abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-  declare _Env: () => Env;
-  declare _InErr: (_: InErr) => void;
-  declare _InElem: (_: InElem) => void;
-  declare _InDone: (_: InDone) => void;
-  declare _OutErr: () => OutErr;
-  declare _OutElem: () => OutElem;
-  declare _OutDone: () => OutDone;
+  readonly [ChannelTypeId]: ChannelTypeId = ChannelTypeId;
+  declare [ChannelVariance]: {
+    _Env: () => Env;
+    _InErr: (_: InErr) => void;
+    _InElem: (_: InElem) => void;
+    _InDone: (_: InDone) => void;
+    _OutErr: () => OutErr;
+    _OutElem: () => OutElem;
+    _OutDone: () => OutDone;
+  };
 }
 
 /**
@@ -43,49 +52,63 @@ export function unifyChannel<X extends Channel<any, any, any, any, any, any, any
 ): Channel<
   [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

package/_src/Channel/internal/ChannelExecutor.ts

@@ -1049,17 +1049,28 @@ export class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDon
     this.doneStack = this.doneStack.prepend(new ContinuationFinalizer(f));
   }
 
+  private provide<Env, OutErr, OutDone>(
+    io: IO<Env, OutErr, OutDone>,
+    __tsplusTrace?: string,
+  ): IO<Env, OutErr, OutDone> {
+    if (this.providedEnv === null) {
+      return io;
+    } else {
+      return io.provideEnvironment(this.providedEnv);
+    }
+  }
+
   private runBracketOut(bracketOut: BracketOut<Env, unknown, unknown, unknown>): ChannelState<Env, unknown> | null {
     return new State.Effect(
-      IO.uninterruptibleMask(({ restore }) =>
-        restore(bracketOut.acquire).matchCauseIO(
+      IO.uninterruptible(
+        this.provide(bracketOut.acquire).matchCauseIO(
           (cause) =>
             IO.succeed(() => {
               this.currentChannel = Channel.failCause(cause);
             }),
           (out) =>
             IO.succeed(() => {
-              this.addFinalizer((e) => bracketOut.finalizer(out, e));
+              this.addFinalizer((e) => this.provide(bracketOut.finalizer(out, e)));
               this.currentChannel = Channel.write(() => out);
             }),
         ),

package/_src/Channel/internal/MergeDecision.ts

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

package/_src/CountdownLatch.ts

@@ -6,7 +6,7 @@ export type CountdownLatchTypeId = typeof CountdownLatchTypeId;
  * @tsplus companion fncts.io.CountdownLatchOps
  */
 export class CountdownLatch {
-  readonly _typeId: CountdownLatchTypeId = CountdownLatchTypeId;
+  readonly [CountdownLatchTypeId]: CountdownLatchTypeId = CountdownLatchTypeId;
   constructor(private _count: Ref<number>, private _waiters: Future<never, void>) {}
 
   readonly await: UIO<void> = this._waiters.await;

package/_src/Differ/definition.ts

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

package/_src/Fiber/FiberRuntime.ts

@@ -3,7 +3,7 @@ import type { OnFailure, OnSuccess, OnSuccessAndFailure, UIO } from "../IO/defin
 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 { StackTraceBuilder } from "@fncts/io/internal/StackTraceBuilder";
 
 import { Done, Suspended } from "../FiberStatus.js";
@@ -12,23 +12,18 @@ import { FiberStatusTag } from "../FiberStatus.js";
 import { LinkedQueue } from "../internal/MutableQueue.js";
 import { isIO } from "../IO/definition.js";
 import { WhileLoop } from "../IO/definition.js";
-import { IOTag } from "../IO/definition.js";
+import { IOOpCode } from "../IO/definition.js";
 import { isIOError } from "../IO/definition.js";
 import { RuntimeFlag } from "../RuntimeFlag.js";
 import { FiberMessage, FiberMessageTag } from "./FiberMessage.js";
 
-const enum ContinuationTag {
-  RevertFlags = "RevertFlags",
-  UpdateTrace = "UpdateTrace",
-}
-
 export class RevertFlags {
-  readonly _tag = ContinuationTag.RevertFlags;
+  readonly ioOpCode = IOOpCode.RevertFlags;
   constructor(readonly patch: RuntimeFlags.Patch, readonly trace?: string) {}
 }
 
 export class UpdateTrace {
-  readonly _tag = ContinuationTag.UpdateTrace;
+  readonly ioOpCode = IOOpCode.UpdateTrace;
   constructor(readonly trace?: string) {}
 }
 
@@ -44,10 +39,13 @@ export type Continuation =
  * @tsplus type fncts.io.Fiber
  */
 export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
-  readonly _E!: () => E;
-  readonly _A!: () => A;
-  readonly _typeId: FiberTypeId = FiberTypeId;
-  readonly _tag                 = "RuntimeFiber";
+  readonly [FiberTypeId]: FiberTypeId = FiberTypeId;
+  declare [FiberVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+  readonly _tag = "RuntimeFiber";
+
   constructor(readonly fiberId: FiberId.Runtime, fiberRefs0: FiberRefs, readonly runtimeFlags0: RuntimeFlags) {
     this._fiberRefs    = fiberRefs0;
     this._runtimeFlags = runtimeFlags0;
@@ -269,7 +267,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
           }
         } catch (e) {
           if (isIO(e)) {
-            if (IO.concrete(e)._tag === IOTag.YieldNow) {
+            if (IO.concrete(e).ioOpCode === IOOpCode.YieldNow) {
               if (this._runtimeFlags.cooperativeYielding) {
                 this.tell(FiberMessage.YieldNow);
                 this.tell(FiberMessage.Resume(IO.unit));
@@ -277,10 +275,10 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
               } else {
                 effect = IO.unit;
               }
-            } else if (IO.concrete(e)._tag === IOTag.Async) {
+            } else if (IO.concrete(e).ioOpCode === IOOpCode.Async) {
               effect = null!;
             } else {
-              throw new Error(`Unhandled op ${IO.concrete(e)._tag}`);
+              throw new Error(`Unhandled op ${IO.concrete(e).ioOpCode}`);
             }
           } else {
             throw e;
@@ -317,18 +315,18 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
         cur          = IO.concrete(IO.yieldNow.flatMap(() => oldCur, trace));
       }
       try {
-        switch (cur._tag) {
-          case IOTag.Sync: {
+        switch (cur.ioOpCode) {
+          case IOOpCode.Sync: {
             const value = cur.evaluate();
             const cont  = this.getNextSuccessCont();
             if (cont) {
-              switch (cont._tag) {
-                case IOTag.OnSuccess:
-                case IOTag.OnSuccessAndFailure: {
+              switch (cont.ioOpCode) {
+                case IOOpCode.OnSuccess:
+                case IOOpCode.OnSuccessAndFailure: {
                   cur = IO.concrete(cont.successK(value));
                   break;
                 }
-                case IOTag.WhileLoop: {
+                case IOOpCode.WhileLoop: {
                   cont.process(value);
                   if (cont.check()) {
                     this.stack.push(cont);
@@ -338,7 +336,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                   }
                   break;
                 }
-                case ContinuationTag.RevertFlags: {
+                case IOOpCode.RevertFlags: {
                   this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
                   if (this._runtimeFlags.interruptible && this.isInterrupted()) {
                     cur = IO.concrete(IO.failCauseNow(this.getInterruptedCause()));
@@ -347,7 +345,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                   }
                   break;
                 }
-                case ContinuationTag.UpdateTrace: {
+                case IOOpCode.UpdateTrace: {
                   if (cont.trace !== undefined) lastTrace = cont.trace;
                   cur = IO.concrete(IO.unit);
                   break;
@@ -358,20 +356,20 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOTag.OnSuccessAndFailure:
-          case IOTag.OnFailure:
-          case IOTag.OnSuccess: {
+          case IOOpCode.OnSuccessAndFailure:
+          case IOOpCode.OnFailure:
+          case IOOpCode.OnSuccess: {
             this.stack.push(cur);
             cur = IO.concrete(cur.first);
             break;
           }
-          case IOTag.Async: {
+          case IOOpCode.Async: {
             this.asyncTrace     = lastTrace;
             this.asyncBlockinOn = cur.blockingOn();
             this.initiateAsync(this._runtimeFlags, cur.registerCallback);
             throw cur;
           }
-          case IOTag.UpdateRuntimeFlagsWithin: {
+          case IOOpCode.UpdateRuntimeFlagsWithin: {
             const updateFlags     = cur.update;
             const oldRuntimeFlags = this._runtimeFlags;
             const newRuntimeFlags = updateFlags.patch(oldRuntimeFlags);
@@ -390,25 +388,25 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOTag.GenerateStackTrace: {
+          case IOOpCode.GenerateStackTrace: {
             cur = IO.concrete(IO.succeedNow(this.generateStackTrace()));
             break;
           }
-          case IOTag.Stateful: {
+          case IOOpCode.Stateful: {
             cur = IO.concrete(cur.onState(this, new Running(this._runtimeFlags, lastTrace)));
             break;
           }
-          case IOTag.SucceedNow: {
+          case IOOpCode.SucceedNow: {
             const oldCur = cur;
             const cont   = this.getNextSuccessCont();
             if (cont) {
-              switch (cont._tag) {
-                case IOTag.OnSuccess:
-                case IOTag.OnSuccessAndFailure: {
+              switch (cont.ioOpCode) {
+                case IOOpCode.OnSuccess:
+                case IOOpCode.OnSuccessAndFailure: {
                   cur = IO.concrete(cont.successK(oldCur.value));
                   break;
                 }
-                case IOTag.WhileLoop: {
+                case IOOpCode.WhileLoop: {
                   cont.process(oldCur.value);
                   if (cont.check()) {
                     this.stack.push(cont);
@@ -418,14 +416,14 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                   }
                   break;
                 }
-                case ContinuationTag.RevertFlags: {
+                case IOOpCode.RevertFlags: {
                   this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
                   if (this._runtimeFlags.interruptible && this.isInterrupted()) {
                     cur = IO.concrete(IO.failCauseNow(this.getInterruptedCause()));
                   }
                   break;
                 }
-                case ContinuationTag.UpdateTrace: {
+                case IOOpCode.UpdateTrace: {
                   if (cont.trace !== undefined) lastTrace = cont.trace;
                   cur = IO.concrete(IO.unit);
                   break;
@@ -436,13 +434,13 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOTag.Fail: {
+          case IOOpCode.Fail: {
             const cause = cur.cause();
             const cont  = this.getNextFailCont();
             if (cont) {
-              switch (cont._tag) {
-                case IOTag.OnFailure:
-                case IOTag.OnSuccessAndFailure: {
+              switch (cont.ioOpCode) {
+                case IOOpCode.OnFailure:
+                case IOOpCode.OnSuccessAndFailure: {
                   if (!(this._runtimeFlags.interruptible && this.isInterrupted())) {
                     cur = IO.concrete(cont.failureK(cause));
                   } else {
@@ -450,7 +448,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                   }
                   break;
                 }
-                case ContinuationTag.RevertFlags: {
+                case IOOpCode.RevertFlags: {
                   this.patchRuntimeFlags(this._runtimeFlags, cont.patch);
                   if (this._runtimeFlags.interruptible && this.isInterrupted()) {
                     const interruptedCause = this.getInterruptedCause();
@@ -462,7 +460,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
                   }
                   break;
                 }
-                case ContinuationTag.UpdateTrace: {
+                case IOOpCode.UpdateTrace: {
                   if (cont.trace !== undefined) lastTrace = cont.trace;
                   cur = IO.concrete(IO.unit);
                   break;
@@ -473,12 +471,12 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOTag.UpdateRuntimeFlags: {
+          case IOOpCode.UpdateRuntimeFlags: {
             this.patchRuntimeFlags(this._runtimeFlags, cur.update);
             cur = IO.concrete(IO.unit);
             break;
           }
-          case IOTag.WhileLoop: {
+          case IOOpCode.WhileLoop: {
             const iterate = cur;
             const check   = iterate.check;
             const body    = iterate.body;
@@ -490,14 +488,20 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             }
             break;
           }
-          case IOTag.YieldNow: {
+          case IOOpCode.YieldNow: {
             throw cur;
           }
+          case IOOpCode.Commit: {
+            cur = IO.concrete(cur.commit);
+          }
         }
       } catch (e) {
         if (isIOError(e)) {
           cur = IO.concrete(IO.failCauseNow(e.cause));
-        } else if (isIO(e) && (IO.concrete(e)._tag === IOTag.Async || IO.concrete(e)._tag === IOTag.YieldNow)) {
+        } else if (
+          isIO(e) &&
+          (IO.concrete(e).ioOpCode === IOOpCode.Async || IO.concrete(e).ioOpCode === IOOpCode.YieldNow)
+        ) {
           throw e;
         } else if (isInterruptedException(e)) {
           cur = IO.concrete(IO.failCauseNow(Cause.both(Cause.halt(e), Cause.interrupt(FiberId.none))));
@@ -795,7 +799,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextSuccessCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame._tag !== IOTag.OnFailure) {
+      if (frame.ioOpCode !== IOOpCode.OnFailure) {
         return frame;
       }
     }
@@ -804,7 +808,7 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   getNextFailCont() {
     while (this.stack.hasNext) {
       const frame = this.stack.pop()!;
-      if (frame._tag !== IOTag.OnSuccess && frame._tag !== IOTag.WhileLoop) {
+      if (frame.ioOpCode !== IOOpCode.OnSuccess && frame.ioOpCode !== IOOpCode.WhileLoop) {
         return frame;
       }
     }

package/_src/Fiber/definition.ts

@@ -3,9 +3,11 @@ import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
 import type { UIO } from "@fncts/io/IO/definition";
 
-import { IterableWeakMap } from "@fncts/base/collection/weak/IterableWeakMap";
 import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
 
+export const FiberVariance = Symbol.for("fncts.io.Fiber.Variance");
+export type FiberVariance = typeof FiberVariance;
+
 export const FiberTypeId = Symbol.for("fncts.io.Fiber");
 export type FiberTypeId = typeof FiberTypeId;
 
@@ -13,9 +15,11 @@ 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;
+  };
 }
 
 /**
@@ -90,9 +94,12 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
 export class SyntheticFiber<E, A> implements FiberCommon<E, A> {
   readonly _tag = "SyntheticFiber";
 
-  readonly _typeId: FiberTypeId = FiberTypeId;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly [FiberTypeId]: FiberTypeId = FiberTypeId;
+  declare [FiberVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+
   readonly await;
 
   constructor(
@@ -118,7 +125,7 @@ export function concrete<E, A>(_fiber: Fiber<E, A>): asserts _fiber is ConcreteF
 }
 
 export function isFiber(u: unknown): u is Fiber<unknown, unknown> {
-  return hasTypeId(u, FiberTypeId);
+  return isObject(u) && FiberTypeId in u;
 }
 
 /**

package/_src/FiberRef/definition.ts

@@ -1,6 +1,9 @@
 import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
 
-export const FiberRefTypeId = Symbol.for("fncts.FiberRef");
+export const FiberRefVariance = Symbol.for("fncts.io.FiberRef.Variance");
+export type FiberRefVariance = typeof FiberRefVariance;
+
+export const FiberRefTypeId = Symbol.for("fncts.io.FiberRef");
 export type FiberRefTypeId = typeof FiberRefTypeId;
 
 /**
@@ -8,8 +11,10 @@ export type FiberRefTypeId = typeof FiberRefTypeId;
  * @tsplus companion fncts.io.FiberRefOps
  */
 export abstract class FiberRef<Value> {
-  readonly _typeId: FiberRefTypeId = FiberRefTypeId;
-  readonly _A!: () => Value;
+  readonly [FiberRefTypeId]: FiberRefTypeId = FiberRefTypeId;
+  declare [FiberRefVariance]: {
+    readonly _Value: (_: Value) => Value;
+  };
   readonly _Patch!: unknown;
 }
 
@@ -50,7 +55,7 @@ export class FiberRefInternal<Value, Patch> extends FiberRef<Value> implements H
 }
 
 export function isFiberRef(u: unknown): u is FiberRef<unknown> {
-  return hasTypeId(u, FiberRefTypeId);
+  return isObject(u) && FiberRefTypeId in u;
 }
 
 type Concrete<Value, Patch> = FiberRefInternal<Value, Patch>;