effect 2.0.0-next.55 → 2.0.0-next.56

package/src/internal/schedule.ts

@@ -17,7 +17,6 @@ import type * as Schedule from "../Schedule.js"
 import * as ScheduleDecision from "../ScheduleDecision.js"
 import * as Interval from "../ScheduleInterval.js"
 import * as Intervals from "../ScheduleIntervals.js"
-import * as internalCause from "./cause.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as ref from "./ref.js"
@@ -85,7 +84,7 @@ class ScheduleDriverImpl<Env, In, Out> implements Schedule.ScheduleDriver<Env, I
     return core.flatMap(ref.get(this.ref), ([element, _]) => {
       switch (element._tag) {
         case "None": {
-          return core.failSync(() => internalCause.NoSuchElementException())
+          return core.failSync(() => new core.NoSuchElementException())
         }
         case "Some": {
           return core.succeed(element.value)
@@ -422,7 +421,7 @@ export const dayOfMonth = (day: number): Schedule.Schedule<never, unknown, numbe
     (now, _, state) => {
       if (!Number.isInteger(day) || day < 1 || 31 < day) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: dayOfMonth(${day}). Must be in range 1...31`
           )
         )
@@ -451,7 +450,7 @@ export const dayOfWeek = (day: number): Schedule.Schedule<never, unknown, number
     (now, _, state) => {
       if (!Number.isInteger(day) || day < 1 || 7 < day) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: dayOfWeek(${day}). Must be in range 1 (Monday)...7 (Sunday)`
           )
         )
@@ -745,7 +744,7 @@ export const hourOfDay = (hour: number): Schedule.Schedule<never, unknown, numbe
     (now, _, state) => {
       if (!Number.isInteger(hour) || hour < 0 || 23 < hour) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: hourOfDay(${hour}). Must be in range 0...23`
           )
         )
@@ -1001,7 +1000,7 @@ export const minuteOfHour = (minute: number): Schedule.Schedule<never, unknown,
     (now, _, state) => {
       if (!Number.isInteger(minute) || minute < 0 || 59 < minute) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: minuteOfHour(${minute}). Must be in range 0...59`
           )
         )
@@ -1314,7 +1313,7 @@ export const secondOfMinute = (second: number): Schedule.Schedule<never, unknown
     (now, _, state) => {
       if (!Number.isInteger(second) || second < 0 || 59 < second) {
         return core.dieSync(() =>
-          internalCause.IllegalArgumentException(
+          new core.IllegalArgumentException(
             `Invalid argument in: secondOfMinute(${second}). Must be in range 0...59`
           )
         )

package/src/internal/scopedCache.ts

@@ -25,7 +25,7 @@ import * as fiberRuntime from "./fiberRuntime.js"
  *
  * @internal
  */
-export interface CacheState<Key, Error, Value> {
+export interface CacheState<in out Key, out Error, out Value> {
   map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Error, Value>> // mutable by design
   keys: _cache.KeySet<Key> // mutable by design
   accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>> // mutable by design
@@ -80,7 +80,7 @@ export type MapValue<Key, Error, Value> =
   | Refreshing<Key, Error, Value>
 
 /** @internal */
-export interface Complete<Key, Error, Value> {
+export interface Complete<out Key, out Error, out Value> {
   readonly _tag: "Complete"
   readonly key: _cache.MapKey<Key>
   readonly exit: Exit.Exit<Error, readonly [Value, Scope.Scope.Finalizer]>
@@ -90,14 +90,14 @@ export interface Complete<Key, Error, Value> {
 }
 
 /** @internal */
-export interface Pending<Key, Error, Value> {
+export interface Pending<out Key, out Error, out Value> {
   readonly _tag: "Pending"
   readonly key: _cache.MapKey<Key>
   readonly scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
 }
 
 /** @internal */
-export interface Refreshing<Key, Error, Value> {
+export interface Refreshing<out Key, out Error, out Value> {
   readonly _tag: "Refreshing"
   readonly scoped: Effect.Effect<never, never, Effect.Effect<Scope.Scope, Error, Value>>
   readonly complete: Complete<Key, Error, Value>
@@ -182,7 +182,9 @@ const scopedCacheVariance = {
   _Value: (_: never) => _
 }
 
-class ScopedCacheImpl<Key, Environment, Error, Value> implements ScopedCache.ScopedCache<Key, Error, Value> {
+class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value>
+  implements ScopedCache.ScopedCache<Key, Error, Value>
+{
   readonly [ScopedCacheTypeId] = scopedCacheVariance
   readonly cacheState: CacheState<Key, Error, Value>
   constructor(

package/src/internal/scopedRef.ts

@@ -22,7 +22,7 @@ export const ScopedRefTypeId: ScopedRef.ScopedRefTypeId = Symbol.for(
 
 /** @internal */
 const scopedRefVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 /** @internal  */

package/src/internal/sink.ts

@@ -38,7 +38,7 @@ const sinkVariance = {
 }
 
 /** @internal */
-export class SinkImpl<R, E, In, L, Z> implements Sink.Sink<R, E, In, L, Z> {
+export class SinkImpl<out R, out E, in In, out L, out Z> implements Sink.Sink<R, E, In, L, Z> {
   readonly [SinkTypeId] = sinkVariance
   constructor(
     readonly channel: Channel.Channel<R, never, Chunk.Chunk<In>, unknown, E, Chunk.Chunk<L>, Z>
@@ -195,7 +195,10 @@ export const collectAllUntilEffect = <In, R, E>(p: (input: In) => Effect.Effect<
 }
 
 /** @internal */
-export const collectAllWhile = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> =>
+export const collectAllWhile: {
+  <In, Out extends In>(refinement: Refinement<In, Out>): Sink.Sink<never, never, In, In, Chunk.Chunk<Out>>
+  <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>>
+} = <In>(predicate: Predicate<In>): Sink.Sink<never, never, In, In, Chunk.Chunk<In>> =>
   fromChannel(collectAllWhileReader(predicate, Chunk.empty()))
 
 /** @internal */
@@ -432,7 +435,7 @@ export const die = (defect: unknown): Sink.Sink<never, never, unknown, never, ne
 
 /** @internal */
 export const dieMessage = (message: string): Sink.Sink<never, never, unknown, never, never> =>
-  failCause(Cause.die(Cause.RuntimeException(message)))
+  failCause(Cause.die(new Cause.RuntimeException(message)))
 
 /** @internal */
 export const dieSync = (evaluate: LazyArg<unknown>): Sink.Sink<never, never, unknown, never, never> =>

package/src/internal/stack.ts

@@ -1,4 +1,4 @@
 /** @internal */
-export class Stack<A> {
+export class Stack<out A> {
   constructor(readonly value: A, readonly previous?: Stack<A>) {}
 }

package/src/internal/stm/core.ts

@@ -417,7 +417,7 @@ export const contextWithSTM = <R0, R, E, A>(
 ): STM.STM<R0 | R, E, A> => flatMap(context<R0>(), f)
 
 /** @internal */
-export class STMDriver<R, E, A> {
+export class STMDriver<in out R, out E, out A> {
   private contStack: Array<Continuation> = []
   private env: Context.Context<unknown>
 
@@ -483,7 +483,7 @@ export class STMDriver<R, E, A> {
               break
             }
             case "None": {
-              curr = fail(Cause.NoSuchElementException()) as Primitive
+              curr = fail(new Cause.NoSuchElementException()) as Primitive
               break
             }
             case "Right": {
@@ -616,7 +616,7 @@ export const die = (defect: unknown): STM.STM<never, never, never> => dieSync(()
 
 /** @internal */
 export const dieMessage = (message: string): STM.STM<never, never, never> =>
-  dieSync(() => Cause.RuntimeException(message))
+  dieSync(() => new Cause.RuntimeException(message))
 
 /** @internal */
 export const dieSync = (evaluate: LazyArg<unknown>): STM.STM<never, never, never> => {

package/src/internal/stm/stm/stmState.ts

@@ -20,7 +20,7 @@ export type STMStateTypeId = typeof STMStateTypeId
 export type STMState<E, A> = Done<E, A> | Interrupted | Running
 
 /** @internal */
-export interface Done<E, A> extends Equal.Equal {
+export interface Done<out E, out A> extends Equal.Equal {
   readonly [STMStateTypeId]: STMStateTypeId
   readonly _tag: OpCodes.OP_DONE
   readonly exit: Exit.Exit<E, A>

package/src/internal/stm/stm/tExit.ts

@@ -20,7 +20,7 @@ export type TExit<E, A> = Fail<E> | Die | Interrupt | Succeed<A> | Retry
 /** @internal */
 export declare namespace TExit {
   /** @internal */
-  export interface Variance<E, A> {
+  export interface Variance<out E, out A> {
     readonly [TExitTypeId]: {
       readonly _E: (_: never) => E
       readonly _A: (_: never) => A
@@ -35,7 +35,7 @@ const variance = {
 }
 
 /** @internal */
-export interface Fail<E> extends TExit.Variance<E, never>, Equal.Equal {
+export interface Fail<out E> extends TExit.Variance<E, never>, Equal.Equal {
   readonly _tag: OpCodes.OP_FAIL
   readonly error: E
 }
@@ -53,7 +53,7 @@ export interface Interrupt extends TExit.Variance<never, never>, Equal.Equal {
 }
 
 /** @internal */
-export interface Succeed<A> extends TExit.Variance<never, A>, Equal.Equal {
+export interface Succeed<out A> extends TExit.Variance<never, A>, Equal.Equal {
   readonly _tag: OpCodes.OP_SUCCEED
   readonly value: A
 }

package/src/internal/stm/stm/tryCommit.ts

@@ -6,7 +6,7 @@ import type * as Journal from "./journal.js"
 export type TryCommit<E, A> = Done<E, A> | Suspend
 
 /** @internal */
-export interface Done<E, A> {
+export interface Done<out E, out A> {
   readonly _tag: OpCodes.OP_DONE
   readonly exit: Exit.Exit<E, A>
 }

package/src/internal/stm/stm/versioned.ts

@@ -1,4 +1,4 @@
 /** @internal */
-export class Versioned<A> {
+export class Versioned<out A> {
   constructor(readonly value: A) {}
 }

package/src/internal/stm/stm.ts

@@ -1250,11 +1250,11 @@ export const partition = dual<
     f: (a: A) => STM.STM<R, E, A2>
   ) => (
     elements: Iterable<A>
-  ) => STM.STM<R, never, [Array<E>, Array<A2>]>,
+  ) => STM.STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>,
   <R, E, A, A2>(
     elements: Iterable<A>,
     f: (a: A) => STM.STM<R, E, A2>
-  ) => STM.STM<R, never, [Array<E>, Array<A2>]>
+  ) => STM.STM<R, never, [excluded: Array<E>, satisfying: Array<A2>]>
 >(2, (elements, f) =>
   pipe(
     forEach(elements, (a) => either(f(a))),

package/src/internal/stm/tArray.ts

@@ -18,11 +18,11 @@ export const TArrayTypeId: TArray.TArrayTypeId = Symbol.for(TArraySymbolKey) as
 
 /** @internal */
 const tArrayVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 /** @internal */
-export class TArrayImpl<A> implements TArray.TArray<A> {
+export class TArrayImpl<in out A> implements TArray.TArray<A> {
   readonly [TArrayTypeId] = tArrayVariance
   constructor(readonly chunk: Array<TRef.TRef<A>>) {}
 }

package/src/internal/stm/tDeferred.ts

@@ -18,12 +18,12 @@ export const TDeferredTypeId: TDeferred.TDeferredTypeId = Symbol.for(
 
 /** @internal */
 const tDeferredVariance = {
-  _E: (_: never) => _,
-  _A: (_: never) => _
+  _E: (_: any) => _,
+  _A: (_: any) => _
 }
 
 /** @internal */
-class TDeferredImpl<E, A> implements TDeferred.TDeferred<E, A> {
+class TDeferredImpl<in out E, in out A> implements TDeferred.TDeferred<E, A> {
   readonly [TDeferredTypeId] = tDeferredVariance
   constructor(readonly ref: TRef.TRef<Option.Option<Either.Either<E, A>>>) {}
 }

package/src/internal/stm/tMap.ts

@@ -27,12 +27,12 @@ export const TMapTypeId: TMap.TMapTypeId = Symbol.for(
 
 /** @internal */
 const tMapVariance = {
-  _K: (_: never) => _,
-  _V: (_: never) => _
+  _K: (_: any) => _,
+  _V: (_: any) => _
 }
 
 /** @internal */
-class TMapImpl<K, V> implements TMap.TMap<K, V> {
+class TMapImpl<in out K, in out V> implements TMap.TMap<K, V> {
   readonly [TMapTypeId] = tMapVariance
   constructor(
     readonly tBuckets: TRef.TRef<TArray.TArray<Chunk.Chunk<readonly [K, V]>>>,

package/src/internal/stm/tPriorityQueue.ts

@@ -21,11 +21,11 @@ export const TPriorityQueueTypeId: TPriorityQueue.TPriorityQueueTypeId = Symbol.
 
 /** @internal */
 const tPriorityQueueVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 /** @internal */
-export class TPriorityQueueImpl<A> implements TPriorityQueue.TPriorityQueue<A> {
+export class TPriorityQueueImpl<in out A> implements TPriorityQueue.TPriorityQueue<A> {
   readonly [TPriorityQueueTypeId] = tPriorityQueueVariance
   constructor(readonly ref: TRef.TRef<SortedMap.SortedMap<A, [A, ...Array<A>]>>) {}
 }

package/src/internal/stm/tPubSub.ts

@@ -20,16 +20,19 @@ const TPubSubSymbolKey = "effect/TPubSub"
 /** @internal */
 export const TPubSubTypeId: TPubSub.TPubSubTypeId = Symbol.for(TPubSubSymbolKey) as TPubSub.TPubSubTypeId
 
+const AbsentValue = Symbol.for("effect/TPubSub/AbsentValue")
+type AbsentValue = typeof AbsentValue
+
 /** @internal */
-export interface Node<A> {
-  readonly head: A
+export interface Node<in out A> {
+  readonly head: A | AbsentValue
   readonly subscribers: number
   readonly tail: TRef.TRef<Node<A> | undefined>
 }
 
 /** @internal */
 export const makeNode = <A>(
-  head: A,
+  head: A | AbsentValue,
   subscribers: number,
   tail: TRef.TRef<Node<A> | undefined>
 ): Node<A> => ({
@@ -39,8 +42,10 @@ export const makeNode = <A>(
 })
 
 /** @internal */
-class TPubSubImpl<A> implements TPubSub.TPubSub<A> {
-  readonly [TPubSubTypeId]: TPubSub.TPubSubTypeId = TPubSubTypeId
+class TPubSubImpl<in out A> implements TPubSub.TPubSub<A> {
+  readonly [TPubSubTypeId] = {
+    _A: (_: any) => _
+  }
   readonly [tQueue.TEnqueueTypeId] = tQueue.tEnqueueVariance
   constructor(
     readonly pubsubSize: TRef.TRef<number>,
@@ -122,9 +127,9 @@ class TPubSubImpl<A> implements TPubSub.TPubSub<A> {
               }
               const head = node.head
               const tail = node.tail
-              if (head !== undefined) {
-                const updatedNode = makeNode(void 0, node.subscribers, node.tail as any)
-                tRef.unsafeSet<Node<A | undefined> | undefined>(
+              if (head !== AbsentValue) {
+                const updatedNode = makeNode<A>(AbsentValue, node.subscribers, node.tail as any)
+                tRef.unsafeSet<Node<A> | undefined>(
                   currentPublisherHead as any,
                   updatedNode as any,
                   runtime.journal
@@ -171,14 +176,14 @@ class TPubSubImpl<A> implements TPubSub.TPubSub<A> {
 }
 
 /** @internal */
-class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
+class TPubSubSubscriptionImpl<in out A> implements TQueue.TDequeue<A> {
   readonly [TPubSubTypeId]: TPubSub.TPubSubTypeId = TPubSubTypeId
   readonly [tQueue.TDequeueTypeId] = tQueue.tDequeueVariance
   constructor(
     readonly pubsubSize: TRef.TRef<number>,
     readonly publisherHead: TRef.TRef<TRef.TRef<Node<A> | undefined>>,
     readonly requestedCapacity: number,
-    readonly subscriberHead: TRef.TRef<TRef.TRef<Node<A | undefined> | undefined> | undefined>,
+    readonly subscriberHead: TRef.TRef<TRef.TRef<Node<A> | undefined> | undefined>,
     readonly subscriberCount: TRef.TRef<number>,
     readonly subscribers: TRef.TRef<HashSet.HashSet<TRef.TRef<TRef.TRef<Node<A>> | undefined>>>
   ) {}
@@ -209,8 +214,8 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         loop = false
       } else {
         const head = node.head
-        const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-        if (head !== undefined) {
+        const tail: TRef.TRef<Node<A> | undefined> = node.tail
+        if (head !== AbsentValue) {
           size = size + 1
           if (size >= Number.MAX_SAFE_INTEGER) {
             loop = false
@@ -231,7 +236,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    let value: A | undefined = undefined
+    let value: A | AbsentValue = AbsentValue
     let loop = true
     while (loop) {
       const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
@@ -239,15 +244,15 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         return core.retry
       }
       const head = node.head
-      const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-      if (head !== undefined) {
+      const tail: TRef.TRef<Node<A> | undefined> = node.tail
+      if (head !== AbsentValue) {
         value = head
         loop = false
       } else {
         currentSubscriberHead = tail
       }
     }
-    return core.succeed(value!)
+    return core.succeed(value as A)
   })
 
   peekOption: STM.STM<never, never, Option.Option<A>> = core.withSTMRuntime((runtime) => {
@@ -264,8 +269,8 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         loop = false
       } else {
         const head = node.head
-        const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-        if (head !== undefined) {
+        const tail: TRef.TRef<Node<A> | undefined> = node.tail
+        if (head !== AbsentValue) {
           value = Option.some(head)
           loop = false
         } else {
@@ -279,7 +284,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
   shutdown: STM.STM<never, never, void> = core.effect<never, void>((journal) => {
     let currentSubscriberHead = tRef.unsafeGet(this.subscriberHead, journal)
     if (currentSubscriberHead !== undefined) {
-      tRef.unsafeSet<TRef.TRef<Node<A | undefined> | undefined> | undefined>(this.subscriberHead, void 0, journal)
+      tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(this.subscriberHead, void 0, journal)
       let loop = true
       while (loop) {
         const node = tRef.unsafeGet(currentSubscriberHead, journal)
@@ -287,18 +292,18 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
           loop = false
         } else {
           const head = node.head
-          const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-          if (head !== undefined) {
+          const tail: TRef.TRef<Node<A> | undefined> = node.tail
+          if (head !== AbsentValue) {
             const subscribers = node.subscribers
             if (subscribers === 1) {
               const size = tRef.unsafeGet(this.pubsubSize, journal)
-              const updatedNode = makeNode(undefined, 0, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, journal)
+              const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, journal)
               tRef.unsafeSet(this.publisherHead, tail as any, journal)
               tRef.unsafeSet(this.pubsubSize, size - 1, journal)
             } else {
               const updatedNode = makeNode(head, subscribers - 1, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, journal)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, journal)
             }
           }
           currentSubscriberHead = tail
@@ -322,7 +327,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
     if (currentSubscriberHead === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    let value: A | undefined = undefined
+    let value: A | AbsentValue = AbsentValue
     let loop = true
     while (loop) {
       const node = tRef.unsafeGet(currentSubscriberHead, runtime.journal)
@@ -330,20 +335,20 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         return core.retry
       }
       const head = node.head
-      const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-      if (head !== undefined) {
+      const tail: TRef.TRef<Node<A> | undefined> = node.tail
+      if (head !== AbsentValue) {
         const subscribers = node.subscribers
         if (subscribers === 1) {
           const size = tRef.unsafeGet(this.pubsubSize, runtime.journal)
-          const updatedNode = makeNode(void 0, 0, tail)
-          tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+          const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+          tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
           tRef.unsafeSet(this.publisherHead, tail as any, runtime.journal)
           tRef.unsafeSet(this.pubsubSize, size - 1, runtime.journal)
         } else {
           const updatedNode = makeNode(head, subscribers - 1, tail)
-          tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+          tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
         }
-        tRef.unsafeSet<TRef.TRef<Node<A | undefined> | undefined> | undefined>(
+        tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
           this.subscriberHead,
           tail,
           runtime.journal
@@ -354,7 +359,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
         currentSubscriberHead = tail
       }
     }
-    return core.succeed(value!)
+    return core.succeed(value as A)
   })
 
   takeAll: STM.STM<never, never, Array<A>> = this.takeUpTo(Number.POSITIVE_INFINITY)
@@ -373,18 +378,18 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
           n = max
         } else {
           const head = node.head
-          const tail: TRef.TRef<Node<A | undefined> | undefined> = node.tail
-          if (head !== undefined) {
+          const tail: TRef.TRef<Node<A> | undefined> = node.tail
+          if (head !== AbsentValue) {
             const subscribers = node.subscribers
             if (subscribers === 1) {
               const size = tRef.unsafeGet(this.pubsubSize, runtime.journal)
-              const updatedNode = makeNode(void 0, 0, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+              const updatedNode = makeNode<A>(AbsentValue, 0, tail)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
               tRef.unsafeSet(this.publisherHead, tail as any, runtime.journal)
               tRef.unsafeSet(this.pubsubSize, size - 1, runtime.journal)
             } else {
               const updatedNode = makeNode(head, subscribers - 1, tail)
-              tRef.unsafeSet<Node<A | undefined> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
+              tRef.unsafeSet<Node<A> | undefined>(currentSubscriberHead, updatedNode, runtime.journal)
             }
             builder.push(head)
             n = n + 1
@@ -392,7 +397,7 @@ class TPubSubSubscriptionImpl<A> implements TQueue.TDequeue<A> {
           currentSubscriberHead = tail
         }
       }
-      tRef.unsafeSet<TRef.TRef<Node<A | undefined> | undefined> | undefined>(
+      tRef.unsafeSet<TRef.TRef<Node<A> | undefined> | undefined>(
         this.subscriberHead,
         currentSubscriberHead,
         runtime.journal

package/src/internal/stm/tQueue.ts

@@ -81,7 +81,7 @@ export const tEnqueueVariance = {
   _In: (_: unknown) => _
 }
 
-class TQueueImpl<A> implements TQueue.TQueue<A> {
+class TQueueImpl<in out A> implements TQueue.TQueue<A> {
   readonly [TDequeueTypeId] = tDequeueVariance
   readonly [TEnqueueTypeId] = tEnqueueVariance
   constructor(
@@ -140,10 +140,10 @@ class TQueueImpl<A> implements TQueue.TQueue<A> {
           return core.succeed(false)
         }
         case OpCodes.OP_SLIDING_STRATEGY: {
-          const dequeued = queue.shift()
-          if (dequeued === undefined) {
+          if (queue.length === 0) {
             return core.succeed(true)
           }
+          queue.shift()
           queue.push(value)
           tRef.unsafeSet(this.ref, queue, runtime.journal)
           return core.succeed(true)
@@ -188,11 +188,10 @@ class TQueueImpl<A> implements TQueue.TQueue<A> {
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    const head = queue[0]
-    if (head === undefined) {
+    if (queue.length === 0) {
       return core.retry
     }
-    return core.succeed(head)
+    return core.succeed(queue[0])
   })
 
   peekOption: STM.STM<never, never, Option.Option<A>> = core.withSTMRuntime((runtime) => {
@@ -208,10 +207,10 @@ class TQueueImpl<A> implements TQueue.TQueue<A> {
     if (queue === undefined) {
       return core.interruptAs(runtime.fiberId)
     }
-    const dequeued = queue.shift()
-    if (dequeued === undefined) {
+    if (queue.length === 0) {
       return core.retry
     }
+    const dequeued = queue.shift()!
     tRef.unsafeSet(this.ref, queue, runtime.journal)
     return core.succeed(dequeued)
   })

package/src/internal/stm/tReentrantLock.ts

@@ -44,11 +44,11 @@ export interface LockState {
   /**
    * Computes the number of read locks held by the specified fiber id.
    */
-  readonly readLocksHeld: (fiberId: FiberId.FiberId) => number
+  readLocksHeld(fiberId: FiberId.FiberId): number
   /**
    * Computes the number of write locks held by the specified fiber id.
    */
-  readonly writeLocksHeld: (fiberId: FiberId.FiberId) => number
+  writeLocksHeld(fiberId: FiberId.FiberId): number
 }
 
 /**

package/src/internal/stm/tRef.ts

@@ -22,7 +22,7 @@ const tRefVariance = {
 }
 
 /** @internal */
-export class TRefImpl<A> implements TRef.TRef<A> {
+export class TRefImpl<in out A> implements TRef.TRef<A> {
   readonly [TRefTypeId] = tRefVariance
   /** @internal */
   todos: Map<TxnId.TxnId, Journal.Todo>

package/src/internal/stm/tSemaphore.ts

@@ -36,7 +36,7 @@ export const acquireN = dual<
 >(2, (self, n) =>
   core.withSTMRuntime((driver) => {
     if (n < 0) {
-      throw Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.acquireN`)
+      throw new Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.acquireN`)
     }
     const value = tRef.unsafeGet(self.permits, driver.journal)
     if (value < n) {
@@ -59,7 +59,7 @@ export const releaseN = dual<
 >(2, (self, n) =>
   core.withSTMRuntime((driver) => {
     if (n < 0) {
-      throw Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.releaseN`)
+      throw new Cause.IllegalArgumentException(`Unexpected negative value ${n} passed to Semaphore.releaseN`)
     }
     const current = tRef.unsafeGet(self.permits, driver.journal)
     return STM.succeed(tRef.unsafeSet(self.permits, current + n, driver.journal))

package/src/internal/stm/tSet.ts

@@ -20,11 +20,11 @@ export const TSetTypeId: TSet.TSetTypeId = Symbol.for(
 
 /** @internal */
 const tSetVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
 }
 
 /** @internal */
-class TSetImpl<A> implements TSet.TSet<A> {
+class TSetImpl<in out A> implements TSet.TSet<A> {
   readonly [TSetTypeId] = tSetVariance
   constructor(readonly tMap: TMap.TMap<A, void>) {}
 }