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

package/src/internal/pubsub.ts

@@ -9,31 +9,33 @@ import { pipeArguments } from "../Pipeable.js"
 import type * as PubSub from "../PubSub.js"
 import type * as Queue from "../Queue.js"
 import type * as Scope from "../Scope.js"
-import * as cause from "./cause.js"
 import * as core from "./core.js"
 import * as executionStrategy from "./executionStrategy.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 import * as queue from "./queue.js"
 
+const AbsentValue = Symbol.for("effect/PubSub/AbsentValue")
+type AbsentValue = typeof AbsentValue
+
 /** @internal */
-export interface AtomicPubSub<A> {
+export interface AtomicPubSub<in out A> {
   readonly capacity: number
-  readonly isEmpty: () => boolean
-  readonly isFull: () => boolean
-  readonly size: () => number
-  readonly publish: (value: A) => boolean
-  readonly publishAll: (elements: Iterable<A>) => Chunk.Chunk<A>
-  readonly slide: () => void
-  readonly subscribe: () => Subscription<A>
+  isEmpty(): boolean
+  isFull(): boolean
+  size(): number
+  publish(value: A): boolean
+  publishAll(elements: Iterable<A>): Chunk.Chunk<A>
+  slide(): void
+  subscribe(): Subscription<A>
 }
 
 /** @internal */
-interface Subscription<A> {
-  readonly isEmpty: () => boolean
-  readonly size: () => number
-  readonly poll: <D>(default_: D) => A | D
-  readonly pollUpTo: (n: number) => Chunk.Chunk<A>
-  readonly unsubscribe: () => void
+interface Subscription<out A> {
+  isEmpty(): boolean
+  size(): number
+  poll<D>(default_: D): A | D
+  pollUpTo(n: number): Chunk.Chunk<A>
+  unsubscribe(): void
 }
 
 /** @internal */
@@ -190,7 +192,7 @@ export const unsafeMakeSubscription = <A>(
 }
 
 /** @internal */
-class BoundedPubSubArb<A> implements AtomicPubSub<A> {
+class BoundedPubSubArb<in out A> implements AtomicPubSub<A> {
   array: Array<A>
   publisherIndex = 0
   subscribers: Array<number>
@@ -254,7 +256,7 @@ class BoundedPubSubArb<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex % this.capacity
-      this.array[index] = null as unknown as A
+      this.array[index] = AbsentValue as unknown as A
       this.subscribers[index] = 0
       this.subscribersIndex += 1
     }
@@ -266,7 +268,7 @@ class BoundedPubSubArb<A> implements AtomicPubSub<A> {
   }
 }
 
-class BoundedPubSubArbSubscription<A> implements Subscription<A> {
+class BoundedPubSubArbSubscription<in out A> implements Subscription<A> {
   constructor(
     private self: BoundedPubSubArb<A>,
     private subscriberIndex: number,
@@ -299,7 +301,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
       const elem = this.self.array[index]!
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       this.subscriberIndex += 1
@@ -325,7 +327,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
       const a = this.self.array[index] as A
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       builder.push(a)
@@ -344,7 +346,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
         const index = this.subscriberIndex % this.self.capacity
         this.self.subscribers[index] -= 1
         if (this.self.subscribers[index] === 0) {
-          this.self.array[index] = null as unknown as A
+          this.self.array[index] = AbsentValue as unknown as A
           this.self.subscribersIndex += 1
         }
         this.subscriberIndex += 1
@@ -354,7 +356,7 @@ class BoundedPubSubArbSubscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class BoundedPubSubPow2<A> implements AtomicPubSub<A> {
+class BoundedPubSubPow2<in out A> implements AtomicPubSub<A> {
   array: Array<A>
   mask: number
   publisherIndex = 0
@@ -420,7 +422,7 @@ class BoundedPubSubPow2<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.subscribersIndex !== this.publisherIndex) {
       const index = this.subscribersIndex & this.mask
-      this.array[index] = null as unknown as A
+      this.array[index] = AbsentValue as unknown as A
       this.subscribers[index] = 0
       this.subscribersIndex += 1
     }
@@ -433,7 +435,7 @@ class BoundedPubSubPow2<A> implements AtomicPubSub<A> {
 }
 
 /** @internal */
-class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
+class BoundedPubSubPow2Subscription<in out A> implements Subscription<A> {
   constructor(
     private self: BoundedPubSubPow2<A>,
     private subscriberIndex: number,
@@ -466,7 +468,7 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
       const elem = this.self.array[index]!
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       this.subscriberIndex += 1
@@ -492,7 +494,7 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
       const elem = this.self.array[index] as A
       this.self.subscribers[index] -= 1
       if (this.self.subscribers[index] === 0) {
-        this.self.array[index] = null as unknown as A
+        this.self.array[index] = AbsentValue as unknown as A
         this.self.subscribersIndex += 1
       }
       builder.push(elem)
@@ -510,7 +512,7 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
         const index = this.subscriberIndex & this.self.mask
         this.self.subscribers[index] -= 1
         if (this.self.subscribers[index] === 0) {
-          this.self.array[index] = null as unknown as A
+          this.self.array[index] = AbsentValue as unknown as A
           this.self.subscribersIndex += 1
         }
         this.subscriberIndex += 1
@@ -520,11 +522,11 @@ class BoundedPubSubPow2Subscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class BoundedPubSubSingle<A> implements AtomicPubSub<A> {
+class BoundedPubSubSingle<in out A> implements AtomicPubSub<A> {
   publisherIndex = 0
   subscriberCount = 0
   subscribers = 0
-  value: A = null as unknown as A
+  value: A = AbsentValue as unknown as A
 
   readonly capacity = 1
 
@@ -571,7 +573,7 @@ class BoundedPubSubSingle<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.isFull()) {
       this.subscribers = 0
-      this.value = null as unknown as A
+      this.value = AbsentValue as unknown as A
     }
   }
 
@@ -582,7 +584,7 @@ class BoundedPubSubSingle<A> implements AtomicPubSub<A> {
 }
 
 /** @internal */
-class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
+class BoundedPubSubSingleSubscription<in out A> implements Subscription<A> {
   constructor(
     private self: BoundedPubSubSingle<A>,
     private subscriberIndex: number,
@@ -609,7 +611,7 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
     const elem = this.self.value
     this.self.subscribers -= 1
     if (this.self.subscribers === 0) {
-      this.self.value = null as unknown as A
+      this.self.value = AbsentValue as unknown as A
     }
     this.subscriberIndex += 1
     return elem
@@ -622,7 +624,7 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
     const a = this.self.value
     this.self.subscribers -= 1
     if (this.self.subscribers === 0) {
-      this.self.value = null as unknown as A
+      this.self.value = AbsentValue as unknown as A
     }
     this.subscriberIndex += 1
     return Chunk.of(a)
@@ -635,7 +637,7 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
       if (this.subscriberIndex !== this.self.publisherIndex) {
         this.self.subscribers -= 1
         if (this.self.subscribers === 0) {
-          this.self.value = null as unknown as A
+          this.self.value = AbsentValue as unknown as A
         }
       }
     }
@@ -643,9 +645,9 @@ class BoundedPubSubSingleSubscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class Node<A> {
+class Node<out A> {
   constructor(
-    public value: A | null,
+    public value: A | AbsentValue,
     public subscribers: number,
     public next: Node<A> | null
   ) {
@@ -653,8 +655,8 @@ class Node<A> {
 }
 
 /** @internal */
-class UnboundedPubSub<A> implements AtomicPubSub<A> {
-  publisherHead = new Node<A>(null, 0, null)
+class UnboundedPubSub<in out A> implements AtomicPubSub<A> {
+  publisherHead = new Node<A>(AbsentValue, 0, null)
   publisherIndex = 0
   publisherTail: Node<A>
   subscribersIndex = 0
@@ -697,7 +699,7 @@ class UnboundedPubSub<A> implements AtomicPubSub<A> {
   slide(): void {
     if (this.publisherHead !== this.publisherTail) {
       this.publisherHead = this.publisherHead.next!
-      this.publisherHead.value = null
+      this.publisherHead.value = AbsentValue
       this.subscribersIndex += 1
     }
   }
@@ -714,7 +716,7 @@ class UnboundedPubSub<A> implements AtomicPubSub<A> {
 }
 
 /** @internal */
-class UnboundedPubSubSubscription<A> implements Subscription<A> {
+class UnboundedPubSubSubscription<in out A> implements Subscription<A> {
   constructor(
     private self: UnboundedPubSub<A>,
     private subscriberHead: Node<A>,
@@ -733,7 +735,7 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
       if (this.subscriberHead === this.self.publisherTail) {
         loop = false
       } else {
-        if (this.subscriberHead.next!.value !== null) {
+        if (this.subscriberHead.next!.value !== AbsentValue) {
           empty = false
           loop = false
         } else {
@@ -763,12 +765,12 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
         loop = false
       } else {
         const elem = this.subscriberHead.next!.value
-        if (elem !== null) {
+        if (elem !== AbsentValue) {
           polled = elem
           this.subscriberHead.subscribers -= 1
           if (this.subscriberHead.subscribers === 0) {
             this.self.publisherHead = this.self.publisherHead.next!
-            this.self.publisherHead.value = null
+            this.self.publisherHead.value = AbsentValue
             this.self.subscribersIndex += 1
           }
           loop = false
@@ -782,7 +784,7 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
 
   pollUpTo(n: number): Chunk.Chunk<A> {
     const builder: Array<A> = []
-    const default_ = null
+    const default_ = AbsentValue
     let i = 0
     while (i !== n) {
       const a = this.poll(default_ as unknown as A)
@@ -801,11 +803,11 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
       this.unsubscribed = true
       this.self.publisherTail.subscribers -= 1
       while (this.subscriberHead !== this.self.publisherTail) {
-        if (this.subscriberHead.next!.value !== null) {
+        if (this.subscriberHead.next!.value !== AbsentValue) {
           this.subscriberHead.subscribers -= 1
           if (this.subscriberHead.subscribers === 0) {
             this.self.publisherHead = this.self.publisherHead.next!
-            this.self.publisherHead.value = null
+            this.self.publisherHead.value = AbsentValue
             this.self.subscribersIndex += 1
           }
         }
@@ -816,7 +818,7 @@ class UnboundedPubSubSubscription<A> implements Subscription<A> {
 }
 
 /** @internal */
-class SubscriptionImpl<A> implements Queue.Dequeue<A> {
+class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
   [queue.DequeueTypeId] = queue.dequeueVariance
 
   constructor(
@@ -993,8 +995,9 @@ const takeRemainderLoop = <A>(
 }
 
 /** @internal */
-class PubSubImpl<A> implements PubSub.PubSub<A> {
+class PubSubImpl<in out A> implements PubSub.PubSub<A> {
   readonly [queue.EnqueueTypeId] = queue.enqueueVariance
+  readonly [queue.DequeueTypeId] = queue.dequeueVariance
 
   constructor(
     readonly pubsub: AtomicPubSub<A>,
@@ -1176,7 +1179,7 @@ const nextPow2 = (n: number): number => {
 /** @internal */
 const ensureCapacity = (capacity: number): void => {
   if (capacity <= 0) {
-    throw cause.InvalidPubSubCapacityException(`Cannot construct PubSub with capacity of ${capacity}`)
+    throw new core.InvalidPubSubCapacityException(`Cannot construct PubSub with capacity of ${capacity}`)
   }
 }
 
@@ -1228,7 +1231,7 @@ const unsafeRemove = <A>(queue: MutableQueue.MutableQueue<A>, value: A): void =>
  *
  * @internal
  */
-export interface PubSubStrategy<A> {
+export interface PubSubStrategy<in out A> {
   /**
    * Describes any finalization logic associated with this strategy.
    */
@@ -1238,42 +1241,42 @@ export interface PubSubStrategy<A> {
    * Describes how publishers should signal to subscribers that they are
    * waiting for space to become available in the `PubSub`.
    */
-  readonly handleSurplus: (
+  handleSurplus(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     elements: Iterable<A>,
     isShutdown: MutableRef.MutableRef<boolean>
-  ) => Effect.Effect<never, never, boolean>
+  ): Effect.Effect<never, never, boolean>
 
   /**
    * Describes how subscribers should signal to publishers waiting for space
    * to become available in the `PubSub` that space may be available.
    */
-  readonly unsafeOnPubSubEmptySpace: (
+  unsafeOnPubSubEmptySpace(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>
-  ) => void
+  ): void
 
   /**
    * Describes how subscribers waiting for additional values from the `PubSub`
    * should take those values and signal to publishers that they are no
    * longer waiting for additional values.
    */
-  readonly unsafeCompletePollers: (
+  unsafeCompletePollers(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>,
     subscription: Subscription<A>,
     pollers: MutableQueue.MutableQueue<Deferred.Deferred<never, A>>
-  ) => void
+  ): void
 
   /**
    * Describes how publishers should signal to subscribers waiting for
    * additional values from the `PubSub` that new values are available.
    */
-  readonly unsafeCompleteSubscribers: (
+  unsafeCompleteSubscribers(
     pubsub: AtomicPubSub<A>,
     subscribers: Subscribers<A>
-  ) => void
+  ): void
 }
 
 /**
@@ -1285,7 +1288,7 @@ export interface PubSubStrategy<A> {
  *
  * @internal
  */
-class BackPressureStrategy<A> implements PubSubStrategy<A> {
+class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
   publishers: MutableQueue.MutableQueue<
     readonly [
       A,
@@ -1410,7 +1413,7 @@ class BackPressureStrategy<A> implements PubSubStrategy<A> {
  *
  * @internal
  */
-export class DroppingStrategy<A> implements PubSubStrategy<A> {
+export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<never, never, void> {
     return core.unit
   }
@@ -1454,7 +1457,7 @@ export class DroppingStrategy<A> implements PubSubStrategy<A> {
  *
  * @internal
  */
-export class SlidingStrategy<A> implements PubSubStrategy<A> {
+export class SlidingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<never, never, void> {
     return core.unit
   }

package/src/internal/queue.ts

@@ -32,9 +32,22 @@ export const QueueStrategyTypeId: Queue.QueueStrategyTypeId = Symbol.for(
   QueueStrategySymbolKey
 ) as Queue.QueueStrategyTypeId
 
+/** @internal */
+const BackingQueueSymbolKey = "effect/BackingQueue"
+
+/** @internal */
+export const BackingQueueTypeId: Queue.BackingQueueTypeId = Symbol.for(
+  BackingQueueSymbolKey
+) as Queue.BackingQueueTypeId
+
 /** @internal */
 const queueStrategyVariance = {
-  _A: (_: never) => _
+  _A: (_: any) => _
+}
+
+/** @internal */
+const backingQueueVariance = {
+  _A: (_: any) => _
 }
 
 /** @internal */
@@ -48,7 +61,7 @@ export const dequeueVariance = {
 }
 
 /** @internal */
-class QueueImpl<A> implements Queue.Queue<A> {
+class QueueImpl<in out A> implements Queue.Queue<A> {
   readonly [EnqueueTypeId] = enqueueVariance
   readonly [DequeueTypeId] = dequeueVariance
 
@@ -386,7 +399,8 @@ export const make = <A>(
   )
 
 /** @internal */
-export class BackingQueueFromMutableQueue<A> implements Queue.BackingQueue<A> {
+export class BackingQueueFromMutableQueue<in out A> implements Queue.BackingQueue<A> {
+  readonly [BackingQueueTypeId] = backingQueueVariance
   constructor(readonly mutable: MutableQueue.MutableQueue<A>) {}
   poll<Def>(def: Def): A | Def {
     return MutableQueue.poll(this.mutable, def)
@@ -503,7 +517,7 @@ export const droppingStrategy = <A>(): Queue.Strategy<A> => new DroppingStrategy
 export const slidingStrategy = <A>(): Queue.Strategy<A> => new SlidingStrategy()
 
 /** @internal */
-class BackPressureStrategy<A> implements Queue.Strategy<A> {
+class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
   readonly [QueueStrategyTypeId] = queueStrategyVariance
 
   readonly putters = MutableQueue.unbounded<readonly [A, Deferred.Deferred<never, boolean>, boolean]>()
@@ -605,7 +619,7 @@ class BackPressureStrategy<A> implements Queue.Strategy<A> {
 }
 
 /** @internal */
-class DroppingStrategy<A> implements Queue.Strategy<A> {
+class DroppingStrategy<in out A> implements Queue.Strategy<A> {
   readonly [QueueStrategyTypeId] = queueStrategyVariance
 
   surplusSize(): number {
@@ -637,7 +651,7 @@ class DroppingStrategy<A> implements Queue.Strategy<A> {
 }
 
 /** @internal */
-class SlidingStrategy<A> implements Queue.Strategy<A> {
+class SlidingStrategy<in out A> implements Queue.Strategy<A> {
   readonly [QueueStrategyTypeId] = queueStrategyVariance
 
   surplusSize(): number {

package/src/internal/redBlackTree/iterator.ts

@@ -11,7 +11,7 @@ export const Direction = {
 } as const
 
 /** @internal */
-export class RedBlackTreeIterator<K, V> implements Iterator<[K, V]> {
+export class RedBlackTreeIterator<in out K, out V> implements Iterator<[K, V]> {
   private count = 0
 
   constructor(

package/src/internal/redBlackTree/node.ts

@@ -11,7 +11,7 @@ export declare namespace Node {
 }
 
 /** @internal */
-export class Node<K, V> {
+export class Node<out K, out V> {
   constructor(
     public color: Node.Color,
     public key: K,

package/src/internal/redBlackTree.ts

@@ -19,13 +19,18 @@ const RedBlackTreeSymbolKey = "effect/RedBlackTree"
 export const RedBlackTreeTypeId: RBT.TypeId = Symbol.for(RedBlackTreeSymbolKey) as RBT.TypeId
 
 /** @internal */
-export interface RedBlackTreeImpl<K, V> extends RBT.RedBlackTree<K, V> {
+export interface RedBlackTreeImpl<in out K, out V> extends RBT.RedBlackTree<K, V> {
   readonly _ord: Order.Order<K>
   readonly _root: Node.Node<K, V> | undefined
 }
 
+const redBlackTreeVariance = {
+  _Key: (_: any) => _,
+  _Value: (_: never) => _
+}
+
 const RedBlackTreeProto: RBT.RedBlackTree<unknown, unknown> = {
-  [RedBlackTreeTypeId]: RedBlackTreeTypeId,
+  [RedBlackTreeTypeId]: redBlackTreeVariance,
   [Hash.symbol](): number {
     let hash = Hash.hash(RedBlackTreeSymbolKey)
     for (const item of this) {

package/src/internal/ref.ts

@@ -14,7 +14,7 @@ export const refVariance = {
   _A: (_: any) => _
 }
 
-class RefImpl<A> implements Ref.Ref<A> {
+class RefImpl<in out A> implements Ref.Ref<A> {
   readonly [RefTypeId] = refVariance
   constructor(readonly ref: MutableRef.MutableRef<A>) {}
   modify<B>(f: (a: A) => readonly [B, A]): Effect.Effect<never, never, B> {

package/src/internal/reloadable.ts

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

package/src/internal/request.ts

@@ -2,9 +2,10 @@ import type * as Effect from "../Effect.js"
 import { dual } from "../Function.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Request from "../Request.js"
+import type * as Types from "../Types.js"
 import * as completedRequestMap from "./completedRequestMap.js"
 import * as core from "./core.js"
-import * as Data from "./data.js"
+import { StructuralPrototype } from "./effectable.js"
 
 /** @internal */
 const RequestSymbolKey = "effect/Request"
@@ -20,28 +21,53 @@ const requestVariance = {
   _A: (_: never) => _
 }
 
+const RequestPrototype = {
+  ...StructuralPrototype,
+  [RequestTypeId]: requestVariance
+}
+
 /** @internal */
 export const isRequest = (u: unknown): u is Request.Request<unknown, unknown> => hasProperty(u, RequestTypeId)
 
 /** @internal */
 export const of = <R extends Request.Request<any, any>>(): Request.Request.Constructor<R> => (args) =>
-  // @ts-expect-error
-  Data.struct({
-    [RequestTypeId]: requestVariance,
-    ...args
-  })
+  Object.assign(Object.create(RequestPrototype), args)
 
 /** @internal */
 export const tagged = <R extends Request.Request<any, any> & { _tag: string }>(
   tag: R["_tag"]
 ): Request.Request.Constructor<R, "_tag"> =>
-(args) =>
-  // @ts-expect-error
-  Data.struct({
-    [RequestTypeId]: requestVariance,
-    _tag: tag,
-    ...args
-  })
+(args) => {
+  const request = Object.assign(Object.create(RequestPrototype), args)
+  request._tag = tag
+  return request
+}
+
+/** @internal */
+export const Class: new<Error, Success, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
+) => Request.Request<Error, Success> & Readonly<A> = (function() {
+  function Class(this: any, args: any) {
+    if (args) {
+      Object.assign(this, args)
+    }
+  }
+  Class.prototype = RequestPrototype
+  return Class as any
+})()
+
+/** @internal */
+export const TaggedClass = <Tag extends string>(
+  tag: Tag
+): new<Error, Success, A extends Record<string, any>>(
+  args: Types.Equals<Omit<A, keyof Request.Request<unknown, unknown>>, {}> extends true ? void
+    : { readonly [P in keyof A as P extends "_tag" | keyof Request.Request<unknown, unknown> ? never : P]: A[P] }
+) => Request.Request<Error, Success> & Readonly<A> & { readonly _tag: Tag } => {
+  return class TaggedClass extends Class<any, any, any> {
+    readonly _tag = tag
+  } as any
+}
 
 /** @internal */
 export const complete = dual<

package/src/internal/resource.ts

@@ -17,9 +17,9 @@ export const ResourceTypeId: Resource.ResourceTypeId = Symbol.for(
 ) as Resource.ResourceTypeId
 
 /** @internal */
-const cachedVariance = {
-  _E: (_: never) => _,
-  _A: (_: never) => _
+const resourceVariance = {
+  _E: (_: any) => _,
+  _A: (_: any) => _
 }
 
 /** @internal */
@@ -46,7 +46,7 @@ export const manual = <R, E, A>(
     pipe(
       scopedRef.fromAcquire(core.exit(acquire)),
       core.map((ref) => ({
-        [ResourceTypeId]: cachedVariance,
+        [ResourceTypeId]: resourceVariance,
         scopedRef: ref,
         acquire: core.provideContext(acquire, env)
       }))

package/src/internal/ringBuffer.ts

@@ -3,7 +3,7 @@ import { constUndefined } from "../Function.js"
 import * as Option from "../Option.js"
 
 /** @internal */
-export class RingBuffer<A> {
+export class RingBuffer<out A> {
   private array: Array<A | undefined>
   private size = 0
   private current = 0

package/src/internal/runtime.ts

@@ -14,7 +14,6 @@ import * as Predicate from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as _scheduler from "../Scheduler.js"
-import { NoSuchElementException } from "./cause.js"
 import * as InternalCause from "./cause.js"
 import * as core from "./core.js"
 import * as FiberRuntime from "./fiberRuntime.js"
@@ -208,7 +207,7 @@ const fastPath = <R, E, A>(effect: Effect.Effect<R, E, A>): Exit.Exit<E, A> | un
     }
     case "None": {
       // @ts-expect-error
-      return core.exitFail(NoSuchElementException())
+      return core.exitFail(core.NoSuchElementException())
     }
   }
 }
@@ -258,7 +257,7 @@ export const unsafeRunPromiseExit =
     })
 
 /** @internal */
-export class RuntimeImpl<R> implements Runtime.Runtime<R> {
+export class RuntimeImpl<in R> implements Runtime.Runtime<R> {
   constructor(
     readonly context: Context.Context<R>,
     readonly runtimeFlags: RuntimeFlags.RuntimeFlags,