effect 3.8.5 → 3.9.0

package/src/Types.ts

@@ -254,6 +254,18 @@ export type NoInfer<A> = [A][A extends any ? 0 : never]
  */
 export type Invariant<A> = (_: A) => A
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Invariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Invariant<infer U> ? U : never
+}
+
 /**
  * Covariant helper.
  *
@@ -262,6 +274,18 @@ export type Invariant<A> = (_: A) => A
  */
 export type Covariant<A> = (_: never) => A
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Covariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Covariant<infer U> ? U : never
+}
+
 /**
  * Contravariant helper.
  *
@@ -270,6 +294,18 @@ export type Covariant<A> = (_: never) => A
  */
 export type Contravariant<A> = (_: A) => void
 
+/**
+ * @since 3.9.0
+ * @category models
+ */
+export declare namespace Contravariant {
+  /**
+   * @since 3.9.0
+   * @category models
+   */
+  export type Type<A> = A extends Contravariant<infer U> ? U : never
+}
+
 /**
  * @since 2.0.0
  */
@@ -279,3 +315,8 @@ export type MatchRecord<S, onTrue, onFalse> = {} extends S ? onTrue : onFalse
  * @since 2.0.0
  */
 export type NotFunction<T> = T extends Function ? never : T
+
+/**
+ * @since 3.9.0
+ */
+export type NoExcessProperties<T, U> = T & { readonly [K in Exclude<keyof U, keyof T>]: never }

package/src/Unify.ts

@@ -34,26 +34,21 @@ export declare const ignoreSymbol: unique symbol
  */
 export type ignoreSymbol = typeof ignoreSymbol
 
-type MaybeReturn<F> = F extends () => any ? ReturnType<F> : F
+type MaybeReturn<F> = F extends () => infer R ? R : NonNullable<F>
 
-type Values<X extends [any, any]> = X extends any
-  ? { [k in keyof X[0]]-?: k extends X[1] ? never : MaybeReturn<X[0][k]> }[keyof X[0]]
+type Values<X extends [any, any]> = X extends [infer A, infer Ignore]
+  ? Exclude<keyof A, Ignore> extends infer k ? k extends keyof A ? MaybeReturn<A[k]> : never : never
   : never
 
-type Ignore<X> = X extends {
-  [ignoreSymbol]?: any
-} ? keyof NonNullable<X[ignoreSymbol]>
+type Ignore<X> = X extends { [ignoreSymbol]?: infer Obj } ? keyof NonNullable<Obj>
   : never
 
 type ExtractTypes<
-  X extends {
-    [typeSymbol]?: any
-    [unifySymbol]?: any
-  }
-> = X extends any ? [
-    NonNullable<X[unifySymbol]>,
-    Ignore<X>
-  ]
+  X
+> = X extends {
+  [typeSymbol]?: infer _Type
+  [unifySymbol]?: infer _Unify
+} ? [NonNullable<_Unify>, Ignore<X>]
   : never
 
 type FilterIn<A> = A extends any ? typeSymbol extends keyof A ? A : never : never

package/src/internal/cause.ts

@@ -8,7 +8,7 @@ import { constFalse, constTrue, dual, identity, pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashSet from "../HashSet.js"
-import { NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
@@ -69,6 +69,9 @@ const proto = {
   toString<E>(this: Cause.Cause<E>) {
     return pretty(this)
   },
+  [DenoInspectSymbol]<E>(this: Cause.Cause<E>) {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]<E>(this: Cause.Cause<E>) {
     return this.toJSON()
   }

package/src/internal/context.ts

@@ -3,7 +3,7 @@ import * as Equal from "../Equal.js"
 import type { LazyArg } from "../Function.js"
 import { dual } from "../Function.js"
 import * as Hash from "../Hash.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import type * as O from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -25,7 +25,6 @@ export const STMTypeId: STM.STMTypeId = Symbol.for(
 /** @internal */
 export const TagProto: any = {
   ...EffectPrototype,
-  _tag: "Tag",
   _op: "Tag",
   [STMTypeId]: effectVariance,
   [TagTypeId]: {
@@ -42,6 +41,9 @@ export const TagProto: any = {
       stack: this.stack
     }
   },
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },
@@ -126,6 +128,9 @@ export const ContextProto: Omit<C.Context<unknown>, "unsafeMap"> = {
       services: Array.from(this.unsafeMap).map(toJSON)
     }
   },
+  [DenoInspectSymbol]() {
+    return (this as any).toJSON()
+  },
   [NodeInspectSymbol]() {
     return (this as any).toJSON()
   }

package/src/internal/core-effect.ts

@@ -1055,17 +1055,17 @@ const loopDiscard = <S, X, E, R>(
 
 /* @internal */
 export const mapAccum: {
-  <S, A, B, E, R>(
+  <S, A, B, E, R, I extends Iterable<A> = Iterable<A>>(
     zero: S,
     f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
-  ): (elements: Iterable<A>) => Effect.Effect<[S, Array<B>], E, R>
-  <A, S, B, E, R>(
-    elements: Iterable<A>,
+  ): (elements: I) => Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+  <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+    elements: I,
     zero: S,
     f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
-  ): Effect.Effect<[S, Array<B>], E, R>
-} = dual(3, <A, S, B, E, R>(
-  elements: Iterable<A>,
+  ): Effect.Effect<[S, Arr.ReadonlyArray.With<I, B>], E, R>
+} = dual(3, <A, S, B, E, R, I extends Iterable<A> = Iterable<A>>(
+  elements: I,
   zero: S,
   f: (s: S, a: A, i: number) => Effect.Effect<readonly [S, B], E, R>
 ): Effect.Effect<[S, Array<B>], E, R> =>

package/src/internal/core.ts

@@ -21,7 +21,7 @@ import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashMap from "../HashMap.js"
 import type * as HashSet from "../HashSet.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as List from "../List.js"
 import type * as LogLevel from "../LogLevel.js"
 import type * as LogSpan from "../LogSpan.js"
@@ -177,6 +177,9 @@ class EffectPrimitive {
   toString() {
     return format(this.toJSON())
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -226,6 +229,9 @@ class EffectPrimitiveFailure {
   toString() {
     return format(this.toJSON())
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -275,6 +281,9 @@ class EffectPrimitiveSuccess {
   toString() {
     return format(this.toJSON())
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -2194,6 +2203,9 @@ export const YieldableError: new(message?: string, options?: ErrorOptions) => Ca
     toJSON() {
       return { ...this }
     }
+    [DenoInspectSymbol]() {
+      return this[NodeInspectSymbol]()
+    }
     [NodeInspectSymbol]() {
       if (this.toString !== globalThis.Error.prototype.toString) {
         return this.stack ? `${this.toString()}\n${this.stack.split("\n").slice(1).join("\n")}` : this.toString()

package/src/internal/effect/circular.ts

@@ -112,10 +112,16 @@ export const unsafeMakeSemaphore = (permits: number): Semaphore => new Semaphore
 /** @internal */
 export const makeSemaphore = (permits: number) => core.sync(() => unsafeMakeSemaphore(permits))
 
-class Latch implements Effect.Latch {
+class Latch extends Effectable.Class<void> implements Effect.Latch {
   waiters: Array<(_: Effect.Effect<void>) => void> = []
   scheduled = false
-  constructor(private isOpen: boolean) {}
+  constructor(private isOpen: boolean) {
+    super()
+  }
+
+  commit() {
+    return this.await
+  }
 
   private unsafeSchedule(fiber: Fiber.RuntimeFiber<void>) {
     if (this.scheduled || this.waiters.length === 0) {

package/src/internal/fiberId.ts

@@ -4,7 +4,7 @@ import { dual, pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashSet from "../HashSet.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { hasProperty } from "../Predicate.js"
@@ -58,6 +58,9 @@ class None implements FiberId.None {
       _tag: this._tag
     }
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -91,6 +94,9 @@ class Runtime implements FiberId.Runtime {
       startTimeMillis: this.startTimeMillis
     }
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }
@@ -131,6 +137,9 @@ class Composite implements FiberId.Composite {
       right: toJSON(this.right)
     }
   }
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  }
   [NodeInspectSymbol]() {
     return this.toJSON()
   }

package/src/internal/hashMap.ts

@@ -3,7 +3,7 @@ import * as Dual from "../Function.js"
 import { identity, pipe } from "../Function.js"
 import * as Hash from "../Hash.js"
 import type * as HM from "../HashMap.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
@@ -85,6 +85,9 @@ const HashMapProto: HM.HashMap<unknown, unknown> = {
       values: Array.from(this).map(toJSON)
     }
   },
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/internal/hashSet.ts

@@ -3,7 +3,7 @@ import { dual } from "../Function.js"
 import * as Hash from "../Hash.js"
 import type { HashMap } from "../HashMap.js"
 import type * as HS from "../HashSet.js"
-import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
+import { DenoInspectSymbol, format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import { hasProperty } from "../Predicate.js"
@@ -49,6 +49,9 @@ const HashSetProto: Omit<HashSetImpl<unknown>, "_keyMap"> = {
       values: Array.from(this).map(toJSON)
     }
   },
+  [DenoInspectSymbol]() {
+    return this.toJSON()
+  },
   [NodeInspectSymbol]() {
     return this.toJSON()
   },

package/src/internal/layer.ts

@@ -10,6 +10,7 @@ import type { LazyArg } from "../Function.js"
 import { dual, pipe } from "../Function.js"
 import * as HashMap from "../HashMap.js"
 import type * as Layer from "../Layer.js"
+import type * as ManagedRuntime from "../ManagedRuntime.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
@@ -23,6 +24,7 @@ import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as circular from "./effect/circular.js"
 import * as fiberRuntime from "./fiberRuntime.js"
+import * as circularManagedRuntime from "./managedRuntime/circular.js"
 import * as EffectOpCodes from "./opCodes/effect.js"
 import * as OpCodes from "./opCodes/layer.js"
 import * as ref from "./ref.js"
@@ -49,7 +51,7 @@ const layerVariance = {
 }
 
 /** @internal */
-const proto = {
+export const proto = {
   [LayerTypeId]: layerVariance,
   pipe() {
     return pipeArguments(this, arguments)
@@ -79,7 +81,7 @@ export type Primitive =
 
 /** @internal */
 export type Op<Tag extends string, Body = {}> = Layer.Layer<unknown, unknown, unknown> & Body & {
-  readonly _tag: Tag
+  readonly _op_layer: Tag
 }
 
 /** @internal */
@@ -165,7 +167,7 @@ export const isLayer = (u: unknown): u is Layer.Layer<unknown, unknown, unknown>
 
 /** @internal */
 export const isFresh = <RIn, E, ROut>(self: Layer.Layer<ROut, E, RIn>): boolean => {
-  return (self as Primitive)._tag === OpCodes.OP_FRESH
+  return (self as Primitive)._op_layer === OpCodes.OP_FRESH
 }
 
 // -----------------------------------------------------------------------------
@@ -356,7 +358,7 @@ const makeBuilder = <RIn, E, ROut>(
   inMemoMap = false
 ): Effect.Effect<(memoMap: Layer.MemoMap) => Effect.Effect<Context.Context<ROut>, E, RIn>> => {
   const op = self as Primitive
-  switch (op._tag) {
+  switch (op._op_layer) {
     case "Locally": {
       return core.sync(() => (memoMap: Layer.MemoMap) => op.f(memoMap.getOrElseMemoize(op.self, scope)))
     }
@@ -487,7 +489,7 @@ export const extendScope = <RIn, E, ROut>(
   self: Layer.Layer<ROut, E, RIn>
 ): Layer.Layer<ROut, E, RIn | Scope.Scope> => {
   const extendScope = Object.create(proto)
-  extendScope._tag = OpCodes.OP_EXTEND_SCOPE
+  extendScope._op_layer = OpCodes.OP_EXTEND_SCOPE
   extendScope.layer = self
   return extendScope
 }
@@ -533,7 +535,7 @@ export const flatten = dual<
 /** @internal */
 export const fresh = <A, E, R>(self: Layer.Layer<A, E, R>): Layer.Layer<A, E, R> => {
   const fresh = Object.create(proto)
-  fresh._tag = OpCodes.OP_FRESH
+  fresh._op_layer = OpCodes.OP_FRESH
   fresh.layer = self
   return fresh
 }
@@ -565,7 +567,7 @@ export function fromEffectContext<A, E, R>(
   effect: Effect.Effect<Context.Context<A>, E, R>
 ): Layer.Layer<A, E, R> {
   const fromEffect = Object.create(proto)
-  fromEffect._tag = OpCodes.OP_FROM_EFFECT
+  fromEffect._op_layer = OpCodes.OP_FROM_EFFECT
   fromEffect.effect = effect
   return fromEffect
 }
@@ -587,7 +589,7 @@ export const locallyEffect = dual<
   ) => Layer.Layer<ROut2, E2, RIn2>
 >(2, (self, f) => {
   const locally = Object.create(proto)
-  locally._tag = "Locally"
+  locally._op_layer = "Locally"
   locally.self = self
   locally.f = f
   return locally
@@ -658,7 +660,7 @@ export const matchCause = dual<
   ) => Layer.Layer<A2 & A3, E2 | E3, R | R2 | R3>
 >(2, (self, { onFailure, onSuccess }) => {
   const fold = Object.create(proto)
-  fold._tag = OpCodes.OP_FOLD
+  fold._op_layer = OpCodes.OP_FOLD
   fold.layer = self
   fold.failureK = onFailure
   fold.successK = onSuccess
@@ -866,7 +868,7 @@ export const scopedContext = <A, E, R>(
   effect: Effect.Effect<Context.Context<A>, E, R>
 ): Layer.Layer<A, E, Exclude<R, Scope.Scope>> => {
   const scoped = Object.create(proto)
-  scoped._tag = OpCodes.OP_SCOPED
+  scoped._op_layer = OpCodes.OP_SCOPED
   scoped.effect = effect
   return scoped
 }
@@ -920,7 +922,7 @@ export const suspend = <RIn, E, ROut>(
   evaluate: LazyArg<Layer.Layer<ROut, E, RIn>>
 ): Layer.Layer<ROut, E, RIn> => {
   const suspend = Object.create(proto)
-  suspend._tag = OpCodes.OP_SUSPEND
+  suspend._op_layer = OpCodes.OP_SUSPEND
   suspend.evaluate = evaluate
   return suspend
 }
@@ -1024,29 +1026,52 @@ export const toRuntimeWithMemoMap = dual<
 
 /** @internal */
 export const provide = dual<
-  <RIn, E, ROut>(
-    self: Layer.Layer<ROut, E, RIn>
-  ) => <RIn2, E2, ROut2>(
-    that: Layer.Layer<ROut2, E2, RIn2>
-  ) => Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>,
-  <RIn2, E2, ROut2, RIn, E, ROut>(
-    that: Layer.Layer<ROut2, E2, RIn2>,
-    self: Layer.Layer<ROut, E, RIn>
-  ) => Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
->(2, <RIn2, E2, ROut2, RIn, E, ROut>(
-  that: Layer.Layer<ROut2, E2, RIn2>,
-  self: Layer.Layer<ROut, E, RIn>
+  {
+    <RIn, E, ROut>(
+      that: Layer.Layer<ROut, E, RIn>
+    ): <RIn2, E2, ROut2>(
+      self: Layer.Layer<ROut2, E2, RIn2>
+    ) => Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+    <const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      that: Layers
+    ): <A, E, R>(
+      self: Layer.Layer<A, E, R>
+    ) => Layer.Layer<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
+  },
+  {
+    <RIn2, E2, ROut2, RIn, E, ROut>(
+      self: Layer.Layer<ROut2, E2, RIn2>,
+      that: Layer.Layer<ROut, E, RIn>
+    ): Layer.Layer<ROut2, E | E2, RIn | Exclude<RIn2, ROut>>
+    <A, E, R, const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      self: Layer.Layer<A, E, R>,
+      that: Layers
+    ): Layer.Layer<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
+  }
+>(2, (
+  self: Layer.Layer.Any,
+  that: Layer.Layer.Any | ReadonlyArray<Layer.Layer.Any>
 ) =>
   suspend(() => {
     const provideTo = Object.create(proto)
-    provideTo._tag = OpCodes.OP_PROVIDE
+    provideTo._op_layer = OpCodes.OP_PROVIDE
     provideTo.first = Object.create(proto, {
-      _tag: { value: OpCodes.OP_PROVIDE_MERGE, enumerable: true },
-      first: { value: context<Exclude<RIn2, ROut>>(), enumerable: true },
-      second: { value: self },
-      zipK: { value: (a: Context.Context<ROut>, b: Context.Context<ROut2>) => pipe(a, Context.merge(b)) }
+      _op_layer: { value: OpCodes.OP_PROVIDE_MERGE, enumerable: true },
+      first: { value: context(), enumerable: true },
+      second: { value: Array.isArray(that) ? mergeAll(...that as any) : that },
+      zipK: { value: (a: Context.Context<any>, b: Context.Context<any>) => pipe(a, Context.merge(b)) }
     })
-    provideTo.second = that
+    provideTo.second = self
     return provideTo
   }))
 
@@ -1063,7 +1088,7 @@ export const provideMerge = dual<
   ) => Layer.Layer<ROut | ROut2, E2 | E, RIn | Exclude<RIn2, ROut>>
 >(2, <RIn2, E2, ROut2, RIn, E, ROut>(that: Layer.Layer<ROut2, E2, RIn2>, self: Layer.Layer<ROut, E, RIn>) => {
   const zipWith = Object.create(proto)
-  zipWith._tag = OpCodes.OP_PROVIDE_MERGE
+  zipWith._op_layer = OpCodes.OP_PROVIDE_MERGE
   zipWith.first = self
   zipWith.second = provide(that, self)
   zipWith.zipK = (a: Context.Context<ROut>, b: Context.Context<ROut2>): Context.Context<ROut | ROut2> => {
@@ -1086,7 +1111,7 @@ export const zipWith = dual<
 >(3, (self, that, f) =>
   suspend(() => {
     const zipWith = Object.create(proto)
-    zipWith._tag = OpCodes.OP_ZIP_WITH
+    zipWith._op_layer = OpCodes.OP_ZIP_WITH
     zipWith.first = self
     zipWith.second = that
     zipWith.zipK = f
@@ -1291,6 +1316,16 @@ const provideSomeRuntime = dual<
 /** @internal */
 export const effect_provide = dual<
   {
+    <const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      layers: Layers
+    ): <A, E, R>(
+      self: Effect.Effect<A, E, R>
+    ) => Effect.Effect<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
     <ROut, E2, RIn>(
       layer: Layer.Layer<ROut, E2, RIn>
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, RIn | Exclude<R, ROut>>
@@ -1300,8 +1335,20 @@ export const effect_provide = dual<
     <R2>(
       runtime: Runtime.Runtime<R2>
     ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, R2>>
+    <E2, R2>(
+      managedRuntime: ManagedRuntime.ManagedRuntime<R2, E2>
+    ): <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E | E2, Exclude<R, R2>>
   },
   {
+    <A, E, R, const Layers extends [Layer.Layer.Any, ...Array<Layer.Layer.Any>]>(
+      self: Effect.Effect<A, E, R>,
+      layers: Layers
+    ): Effect.Effect<
+      A,
+      E | { [k in keyof Layers]: Layer.Layer.Error<Layers[k]> }[number],
+      | { [k in keyof Layers]: Layer.Layer.Context<Layers[k]> }[number]
+      | Exclude<R, { [k in keyof Layers]: Layer.Layer.Success<Layers[k]> }[number]>
+    >
     <A, E, R, ROut, E2, RIn>(
       self: Effect.Effect<A, E, R>,
       layer: Layer.Layer<ROut, E2, RIn>
@@ -1314,16 +1361,36 @@ export const effect_provide = dual<
       self: Effect.Effect<A, E, R>,
       runtime: Runtime.Runtime<R2>
     ): Effect.Effect<A, E, Exclude<R, R2>>
+    <A, E, E2, R, R2>(
+      self: Effect.Effect<A, E, R>,
+      managedRuntime: ManagedRuntime.ManagedRuntime<R2, E2>
+    ): Effect.Effect<A, E | E2, Exclude<R, R2>>
   }
 >(
   2,
   <A, E, R, ROut>(
     self: Effect.Effect<A, E, R>,
-    source: Layer.Layer<ROut, any, any> | Context.Context<ROut> | Runtime.Runtime<ROut>
-  ): Effect.Effect<any, any, Exclude<R, ROut>> =>
-    isLayer(source)
-      ? provideSomeLayer(self, source as Layer.Layer<ROut, any, any>)
-      : Context.isContext(source)
-      ? core.provideSomeContext(self, source)
-      : provideSomeRuntime(self, source as Runtime.Runtime<ROut>)
+    source:
+      | Layer.Layer<ROut, any, any>
+      | Context.Context<ROut>
+      | Runtime.Runtime<ROut>
+      | ManagedRuntime.ManagedRuntime<ROut, any>
+      | Array<Layer.Layer.Any>
+  ): Effect.Effect<any, any, Exclude<R, ROut>> => {
+    if (Array.isArray(source)) {
+      // @ts-expect-error
+      return provideSomeLayer(self, mergeAll(...source))
+    } else if (isLayer(source)) {
+      return provideSomeLayer(self, source as Layer.Layer<ROut, any, any>)
+    } else if (Context.isContext(source)) {
+      return core.provideSomeContext(self, source)
+    } else if (circularManagedRuntime.TypeId in source) {
+      return core.flatMap(
+        (source as ManagedRuntime.ManagedRuntime<ROut, any>).runtimeEffect,
+        (rt) => provideSomeRuntime(self, rt)
+      )
+    } else {
+      return provideSomeRuntime(self, source as Runtime.Runtime<ROut>)
+    }
+  }
 )

package/src/internal/mailbox.ts

@@ -287,6 +287,9 @@ class MailboxImpl<A, E> extends Effectable.Class<readonly [messages: Chunk.Chunk
   toString(): string {
     return Inspectable.format(this)
   }
+  [Inspectable.DenoInspectSymbol]() {
+    return Inspectable.format(this)
+  }
   [Inspectable.NodeInspectSymbol]() {
     return Inspectable.format(this)
   }

package/src/internal/managedRuntime/circular.ts

@@ -0,0 +1,6 @@
+import type * as M from "../../ManagedRuntime.js"
+
+// circular with Layer
+
+/** @internal */
+export const TypeId: M.TypeId = Symbol.for("effect/ManagedRuntime") as M.TypeId