effect 2.0.0-next.55 → 2.0.0-next.57

package/src/internal/core.ts

@@ -18,7 +18,7 @@ import { globalValue } from "../GlobalValue.js"
 import * as Hash from "../Hash.js"
 import * as HashMap from "../HashMap.js"
 import * as HashSet from "../HashSet.js"
-import { NodeInspectSymbol, toJSON, toString } from "../Inspectable.js"
+import { 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"
@@ -26,7 +26,7 @@ import type * as MetricLabel from "../MetricLabel.js"
 import * as MutableRef from "../MutableRef.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import { hasProperty, isObject, type Predicate, type Refinement } from "../Predicate.js"
+import { hasProperty, isObject, isPromise, isString, type Predicate, type Refinement } from "../Predicate.js"
 import * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as BlockedRequests from "../RequestBlock.js"
@@ -35,11 +35,12 @@ import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as RuntimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import type * as Scope from "../Scope.js"
 import type * as Tracer from "../Tracer.js"
+import type { NoInfer } from "../Types.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
 import * as internalDiffer from "./differ.js"
-import { effectVariance } from "./effectable.js"
+import { effectVariance, StructuralCommitPrototype } from "./effectable.js"
 import type * as FiberRuntime from "./fiberRuntime.js"
 import type * as fiberScope from "./fiberScope.js"
 import * as DeferredOpCodes from "./opCodes/deferred.js"
@@ -61,7 +62,7 @@ export const EffectErrorTypeId = Symbol.for(EffectErrorSymbolKey)
 export type EffectErrorTypeId = typeof EffectErrorTypeId
 
 /** @internal */
-export interface EffectError<E> {
+export interface EffectError<out E> {
   readonly [EffectErrorTypeId]: EffectErrorTypeId
   readonly _tag: "EffectError"
   readonly cause: Cause.Cause<E>
@@ -80,10 +81,10 @@ export const makeEffectError = <E>(cause: Cause.Cause<E>): EffectError<E> => ({
 /**
  * @internal
  */
-export const blocked = <R, E, A>(
-  blockedRequests: BlockedRequests.RequestBlock<R>,
-  _continue: Effect.Effect<R, E, A>
-): Effect.Blocked<R, E, A> => {
+export const blocked = <E, A>(
+  blockedRequests: BlockedRequests.RequestBlock,
+  _continue: Effect.Effect<never, E, A>
+): Effect.Blocked<E, A> => {
   const effect = new EffectPrimitive("Blocked") as any
   effect.i0 = blockedRequests
   effect.i1 = _continue
@@ -93,9 +94,9 @@ export const blocked = <R, E, A>(
 /**
  * @internal
  */
-export const runRequestBlock = <R>(
-  blockedRequests: BlockedRequests.RequestBlock<R>
-): Effect.Blocked<R, never, void> => {
+export const runRequestBlock = (
+  blockedRequests: BlockedRequests.RequestBlock
+): Effect.Effect<never, never, void> => {
   const effect = new EffectPrimitive("RunBlocked") as any
   effect.i0 = blockedRequests
   return effect
@@ -171,7 +172,7 @@ class EffectPrimitive {
     }
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   [NodeInspectSymbol]() {
     return this.toJSON()
@@ -209,7 +210,7 @@ class EffectPrimitiveFailure {
     }
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   [NodeInspectSymbol]() {
     return this.toJSON()
@@ -247,7 +248,7 @@ class EffectPrimitiveSuccess {
     }
   }
   toString() {
-    return toString(this.toJSON())
+    return format(this.toJSON())
   }
   [NodeInspectSymbol]() {
     return this.toJSON()
@@ -262,23 +263,23 @@ export type Op<Tag extends string, Body = {}> = Effect.Effect<never, never, neve
 /** @internal */
 export interface Async extends
   Op<OpCodes.OP_ASYNC, {
-    readonly i0: (resume: (effect: Primitive) => void) => void
+    i0(resume: (effect: Primitive) => void): void
     readonly i1: FiberId.FiberId
   }>
 {}
 
 /** @internal */
-export interface Blocked<R = any, E = any, A = any> extends
+export interface Blocked<out E = any, out A = any> extends
   Op<"Blocked", {
-    readonly i0: BlockedRequests.RequestBlock<R>
-    readonly i1: Effect.Effect<R, E, A>
+    readonly i0: BlockedRequests.RequestBlock
+    readonly i1: Effect.Effect<never, E, A>
   }>
 {}
 
 /** @internal */
-export interface RunBlocked<R = any> extends
+export interface RunBlocked extends
   Op<"RunBlocked", {
-    readonly i0: BlockedRequests.RequestBlock<R>
+    readonly i0: BlockedRequests.RequestBlock
   }>
 {}
 
@@ -295,7 +296,7 @@ export interface OpTag extends Op<OpCodes.OP_TAG, {}> {}
 /** @internal */
 export interface Commit extends
   Op<OpCodes.OP_COMMIT, {
-    readonly commit: () => Effect.Effect<unknown, unknown, unknown>
+    commit(): Effect.Effect<unknown, unknown, unknown>
   }>
 {}
 
@@ -303,7 +304,7 @@ export interface Commit extends
 export interface OnFailure extends
   Op<OpCodes.OP_ON_FAILURE, {
     readonly i0: Primitive
-    readonly i1: (a: Cause.Cause<unknown>) => Primitive
+    i1(a: Cause.Cause<unknown>): Primitive
   }>
 {}
 
@@ -311,24 +312,19 @@ export interface OnFailure extends
 export interface OnSuccess extends
   Op<OpCodes.OP_ON_SUCCESS, {
     readonly i0: Primitive
-    readonly i1: (a: unknown) => Primitive
+    i1(a: unknown): Primitive
   }>
 {}
 
 /** @internal */
-export interface OnStep extends
-  Op<"OnStep", {
-    readonly i0: Primitive
-    readonly i1: (result: Exit.Exit<any, any> | Blocked) => Primitive
-  }>
-{}
+export interface OnStep extends Op<"OnStep", { readonly i0: Primitive }> {}
 
 /** @internal */
 export interface OnSuccessAndFailure extends
   Op<OpCodes.OP_ON_SUCCESS_AND_FAILURE, {
     readonly i0: Primitive
-    readonly i1: (a: Cause.Cause<unknown>) => Primitive
-    readonly i2: (a: unknown) => Primitive
+    i1(a: Cause.Cause<unknown>): Primitive
+    i2(a: unknown): Primitive
   }>
 {}
 
@@ -342,7 +338,7 @@ export interface Success extends
 /** @internal */
 export interface Sync extends
   Op<OpCodes.OP_SYNC, {
-    readonly i0: LazyArg<unknown>
+    i0(): unknown
   }>
 {}
 
@@ -357,16 +353,16 @@ export interface UpdateRuntimeFlags extends
 /** @internal */
 export interface While extends
   Op<OpCodes.OP_WHILE, {
-    readonly i0: () => boolean
-    readonly i1: () => Primitive
-    readonly i2: (a: unknown) => void
+    i0(): boolean
+    i1(): Primitive
+    i2(a: unknown): void
   }>
 {}
 
 /** @internal */
 export interface WithRuntime extends
   Op<OpCodes.OP_WITH_RUNTIME, {
-    readonly i0: (fiber: FiberRuntime.FiberRuntime<unknown, unknown>, status: FiberStatus.Running) => Primitive
+    i0(fiber: FiberRuntime.FiberRuntime<unknown, unknown>, status: FiberStatus.Running): Primitive
   }>
 {}
 
@@ -405,28 +401,20 @@ export const acquireUseRelease = dual<
     flatMap(
       acquire,
       (a) =>
-        flatMap(exit(suspend(() => restore(step(use(a))))), (exit): Effect.Effect<R | R2 | R3, E | E2, A2> => {
-          if (exit._tag === "Success" && exit.value._op === "Blocked") {
-            const value = exit.value
-            return blocked(
-              value.i0,
-              acquireUseRelease(succeed(a), () => value.i1, release)
-            )
-          }
-          const flat = exitFlatten(exit as Exit.Exit<E2, Exit.Exit<E2, A2>>)
-          return suspend(() => release(a, flat)).pipe(
+        flatMap(exit(suspend(() => restore(use(a)))), (exit): Effect.Effect<R | R2 | R3, E | E2, A2> => {
+          return suspend(() => release(a, exit)).pipe(
             matchCauseEffect({
               onFailure: (cause) => {
-                switch (flat._tag) {
+                switch (exit._tag) {
                   case OpCodes.OP_FAILURE: {
-                    return failCause(internalCause.parallel(flat.i0, cause))
+                    return failCause(internalCause.parallel(exit.i0, cause))
                   }
                   case OpCodes.OP_SUCCESS: {
                     return failCause(cause)
                   }
                 }
               },
-              onSuccess: () => flat
+              onSuccess: () => exit
             })
           )
         })
@@ -451,28 +439,41 @@ export const async = <R, E, A>(
   blockingOn: FiberId.FiberId = FiberId.none
 ): Effect.Effect<R, E, A> =>
   suspend(() => {
+    let backingResume: ((_: Effect.Effect<R, E, A>) => void) | undefined = undefined
+    let pendingEffect: Effect.Effect<R, E, A> | undefined = undefined
+    function proxyResume(effect: Effect.Effect<R, E, A>) {
+      if (backingResume) {
+        backingResume(effect)
+      } else if (pendingEffect === undefined) {
+        pendingEffect = effect
+      }
+    }
+    const effect = new EffectPrimitive(OpCodes.OP_ASYNC) as any
+    effect.i0 = (resume: (_: Effect.Effect<R, E, A>) => void) => {
+      backingResume = resume
+      if (pendingEffect) {
+        resume(pendingEffect)
+      }
+    }
+    effect.i1 = blockingOn
+
     let cancelerRef: Effect.Effect<R, never, void> | void = undefined
     let controllerRef: AbortController | void = undefined
-    const effect = new EffectPrimitive(OpCodes.OP_ASYNC) as any
     if (register.length !== 1) {
-      const controller = new AbortController()
-      controllerRef = controller
-      effect.i0 = (resume: (_: Effect.Effect<R, E, A>) => void) => {
-        cancelerRef = register(resume, controller.signal)
-      }
+      controllerRef = new AbortController()
+      cancelerRef = register(proxyResume, controllerRef.signal)
     } else {
-      effect.i0 = (resume: (_: Effect.Effect<R, E, A>) => void) => {
-        // @ts-expect-error
-        cancelerRef = register(resume)
-      }
+      cancelerRef = (register as any)(proxyResume)
     }
-    effect.i1 = blockingOn
-    return onInterrupt(effect, () => {
-      if (controllerRef) {
-        controllerRef.abort()
-      }
-      return cancelerRef ?? unit
-    })
+
+    return (cancelerRef || controllerRef) ?
+      onInterrupt(effect, (_) => {
+        if (controllerRef) {
+          controllerRef.abort()
+        }
+        return cancelerRef ?? unit
+      }) :
+      effect
   })
 
 /* @internal */
@@ -641,7 +642,7 @@ export const die = (defect: unknown): Effect.Effect<never, never, never> =>
 
 /* @internal */
 export const dieMessage = (message: string): Effect.Effect<never, never, never> =>
-  failCauseSync(() => internalCause.die(internalCause.RuntimeException(message)))
+  failCauseSync(() => internalCause.die(new RuntimeException(message)))
 
 /* @internal */
 export const dieSync = (evaluate: LazyArg<unknown>): Effect.Effect<never, never, never> => flatMap(sync(evaluate), die)
@@ -708,23 +709,56 @@ export const flatMap = dual<
 })
 
 /* @internal */
-export const step = <R, E, A>(
-  self: Effect.Effect<R, E, A>
-): Effect.Effect<R, E, Exit.Exit<E, A> | Effect.Blocked<R, E, A>> => {
-  const effect = new EffectPrimitive("OnStep") as any
-  effect.i0 = self
-  effect.i1 = exitSucceed
-  return effect
-}
+export const andThen = dual<
+  {
+    <A, X>(
+      f: (a: NoInfer<A>) => X
+    ): <R, E>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+    <X>(
+      f: X
+    ): <R, E, A>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+  },
+  {
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: (a: NoInfer<A>) => X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer A1>] ? Effect.Effect<R | R1, E | E1, A1>
+      : [X] extends [Promise<infer A1>] ? Effect.Effect<R, E | Cause.UnknownException, A1>
+      : Effect.Effect<R, E, X>
+  }
+>(2, (self, f) =>
+  flatMap(self, (a) => {
+    const b = typeof f === "function" ? (f as any)(a) : f
+    if (isEffect(b)) {
+      return b
+    } else if (isPromise(b)) {
+      return async<never, Cause.UnknownException, any>((resume) => {
+        b.then((a) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+      })
+    }
+    return succeed(b)
+  }))
 
 /* @internal */
-export const flatMapStep = <R, E, A, R1, E1, B>(
-  self: Effect.Effect<R, E, A>,
-  f: (step: Exit.Exit<E, A> | Effect.Blocked<R, E, A>) => Effect.Effect<R1, E1, B>
-): Effect.Effect<R | R1, E1, B> => {
+export const step = <R, E, A>(
+  self: Effect.Effect<R, E, A>
+): Effect.Effect<R, never, Exit.Exit<E, A> | Effect.Blocked<E, A>> => {
   const effect = new EffectPrimitive("OnStep") as any
   effect.i0 = self
-  effect.i1 = f
   return effect
 }
 
@@ -893,14 +927,7 @@ export const interruptWith = (fiberId: FiberId.FiberId): Effect.Effect<never, ne
 export const interruptible = <R, E, A>(self: Effect.Effect<R, E, A>): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
-  const _continue = (orBlock: any) => {
-    if (orBlock._tag === "Blocked") {
-      return blocked(orBlock.i0, interruptible(orBlock.i1))
-    } else {
-      return orBlock
-    }
-  }
-  effect.i1 = () => flatMapStep(self, _continue)
+  effect.i1 = () => self
   return effect
 }
 
@@ -910,17 +937,11 @@ export const interruptibleMask = <R, E, A>(
 ): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.enable(_runtimeFlags.Interruption)
-  const _continue = (step: Exit.Exit<E, A> | Effect.Blocked<R, E, A>): Exit.Exit<E, A> | Effect.Blocked<R, E, A> => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, interruptible(step.i1))
-    }
-    return step
-  }
   effect.i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
     _runtimeFlags.interruption(oldFlags)
-      ? step(f(interruptible))
-      : step(f(uninterruptible))
-  return flatMap(effect, _continue)
+      ? f(interruptible)
+      : f(uninterruptible)
+  return effect
 }
 
 /* @internal */
@@ -1062,7 +1083,7 @@ export const orDieWith = dual<
 export const partitionMap = <A, A1, A2>(
   elements: Iterable<A>,
   f: (a: A) => Either.Either<A1, A2>
-): [Array<A1>, Array<A2>] =>
+): [left: Array<A1>, right: Array<A2>] =>
   ReadonlyArray.fromIterable(elements).reduceRight(
     ([lefts, rights], current) => {
       const either = f(current)
@@ -1105,14 +1126,48 @@ export const sync = <A>(evaluate: LazyArg<A>): Effect.Effect<never, never, A> =>
 
 /* @internal */
 export const tap = dual<
-  <A, X extends A, R2, E2, _>(
-    f: (a: X) => Effect.Effect<R2, E2, _>
-  ) => <R, E>(self: Effect.Effect<R, E, A>) => Effect.Effect<R | R2, E | E2, A>,
-  <R, E, A, X extends A, R2, E2, _>(
-    self: Effect.Effect<R, E, A>,
-    f: (a: X) => Effect.Effect<R2, E2, _>
-  ) => Effect.Effect<R | R2, E | E2, A>
->(2, (self, f) => flatMap(self, (a) => as(f(a as any), a)))
+  {
+    <A, X>(
+      f: (a: NoInfer<A>) => X
+    ): <R, E>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+    <X>(
+      f: X
+    ): <R, E, A>(
+      self: Effect.Effect<R, E, A>
+    ) => [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+  },
+  {
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: (a: NoInfer<A>) => X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+    <A, R, E, X>(
+      self: Effect.Effect<R, E, A>,
+      f: X
+    ): [X] extends [Effect.Effect<infer R1, infer E1, infer _A1>] ? Effect.Effect<R | R1, E | E1, A>
+      : [X] extends [Promise<infer _A1>] ? Effect.Effect<R, E | Cause.UnknownException, A>
+      : Effect.Effect<R, E, A>
+  }
+>(2, (self, f) =>
+  flatMap(self, (a) => {
+    const b = typeof f === "function" ? (f as any)(a) : f
+    if (isEffect(b)) {
+      return as(b, a)
+    } else if (isPromise(b)) {
+      return async<never, Cause.UnknownException, any>((resume) => {
+        b.then((_) => resume(succeed(a))).catch((e) => resume(fail(new UnknownException(e))))
+      })
+    }
+    return succeed(a)
+  }))
 
 /* @internal */
 export const transplant = <R, E, A>(
@@ -1153,14 +1208,7 @@ export const uninterruptible: <R, E, A>(self: Effect.Effect<R, E, A>) => Effect.
 ): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
-  effect.i1 = () => flatMapStep(self, _continue)
-  const _continue = (orBlock: any) => {
-    if (orBlock._tag === "Blocked") {
-      return blocked(orBlock.i0, uninterruptible(orBlock.i1))
-    } else {
-      return orBlock
-    }
-  }
+  effect.i1 = () => self
   return effect
 }
 
@@ -1170,17 +1218,11 @@ export const uninterruptibleMask = <R, E, A>(
 ): Effect.Effect<R, E, A> => {
   const effect = new EffectPrimitive(OpCodes.OP_UPDATE_RUNTIME_FLAGS) as any
   effect.i0 = RuntimeFlagsPatch.disable(_runtimeFlags.Interruption)
-  const _continue = (step: Exit.Exit<E, A> | Effect.Blocked<R, E, A>): Exit.Exit<E, A> | Effect.Blocked<R, E, A> => {
-    if (step._op === "Blocked") {
-      return blocked(step.i0, uninterruptible(step.i1))
-    }
-    return step
-  }
   effect.i1 = (oldFlags: RuntimeFlags.RuntimeFlags) =>
     _runtimeFlags.interruption(oldFlags)
-      ? step(f(interruptible))
-      : step(f(uninterruptible))
-  return flatMap(effect, _continue)
+      ? f(interruptible)
+      : f(uninterruptible)
+  return effect
 }
 
 /* @internal */
@@ -1477,9 +1519,9 @@ export const FiberRefTypeId: FiberRef.FiberRefTypeId = Symbol.for(
   FiberRefSymbolKey
 ) as FiberRef.FiberRefTypeId
 
-/** @internal */
 const fiberRefVariance = {
-  _A: (_: never) => _
+  /* c8 ignore next */
+  _A: (_: any) => _
 }
 
 /* @internal */
@@ -1594,14 +1636,16 @@ export const RequestResolverTypeId: RequestResolver.RequestResolverTypeId = Symb
   RequestResolverSymbolKey
 ) as RequestResolver.RequestResolverTypeId
 
-const dataSourceVariance = {
-  _R: (_: never) => _,
-  _A: (_: never) => _
+const requestResolverVariance = {
+  /* c8 ignore next */
+  _A: (_: unknown) => _,
+  /* c8 ignore next */
+  _R: (_: never) => _
 }
 
 /** @internal */
-export class RequestResolverImpl<R, A> implements RequestResolver.RequestResolver<A, R> {
-  readonly [RequestResolverTypeId] = dataSourceVariance
+export class RequestResolverImpl<out R, in A> implements RequestResolver.RequestResolver<A, R> {
+  readonly [RequestResolverTypeId] = requestResolverVariance
   constructor(
     readonly runAll: (
       requests: Array<Array<Request.Entry<A>>>
@@ -1661,16 +1705,16 @@ export const resolverLocally = dual<
   ))
 
 /** @internal */
-export const requestBlockLocally = <R, A>(
-  self: BlockedRequests.RequestBlock<R>,
+export const requestBlockLocally = <A>(
+  self: BlockedRequests.RequestBlock,
   ref: FiberRef.FiberRef<A>,
   value: A
-): BlockedRequests.RequestBlock<R> => _blockedRequests.reduce(self, LocallyReducer(ref, value))
+): BlockedRequests.RequestBlock => _blockedRequests.reduce(self, LocallyReducer(ref, value))
 
-const LocallyReducer = <R, A>(
+const LocallyReducer = <A>(
   ref: FiberRef.FiberRef<A>,
   value: A
-): BlockedRequests.RequestBlock.Reducer<R, BlockedRequests.RequestBlock<R>> => ({
+): BlockedRequests.RequestBlock.Reducer<BlockedRequests.RequestBlock> => ({
   emptyCase: () => _blockedRequests.empty,
   parCase: (left, right) => _blockedRequests.par(left, right),
   seqCase: (left, right) => _blockedRequests.seq(left, right),
@@ -1689,18 +1733,10 @@ export const fiberRefLocally: {
   <A>(self: FiberRef.FiberRef<A>, value: A) => <R, E, B>(use: Effect.Effect<R, E, B>) => Effect.Effect<R, E, B>,
   <R, E, B, A>(use: Effect.Effect<R, E, B>, self: FiberRef.FiberRef<A>, value: A) => Effect.Effect<R, E, B>
 >(3, (use, self, value) =>
-  flatMap(
-    acquireUseRelease(
-      zipLeft(fiberRefGet(self), fiberRefSet(self, value)),
-      () => step(use),
-      (oldValue) => fiberRefSet(self, oldValue)
-    ),
-    (res) => {
-      if (res._op === "Blocked") {
-        return blocked(res.i0, fiberRefLocally(res.i1, self, value))
-      }
-      return res
-    }
+  acquireUseRelease(
+    zipLeft(fiberRefGet(self), fiberRefSet(self, value)),
+    () => use,
+    (oldValue) => fiberRefSet(self, oldValue)
   ))
 
 /* @internal */
@@ -2071,6 +2107,176 @@ export const releaseMapMake: Effect.Effect<never, never, ReleaseMap> = sync(():
   }
 }))
 
+// -----------------------------------------------------------------------------
+// Cause
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export const causeSquash = <E>(self: Cause.Cause<E>): unknown => {
+  return causeSquashWith(identity)(self)
+}
+
+/** @internal */
+export const causeSquashWith = dual<
+  <E>(f: (error: E) => unknown) => (self: Cause.Cause<E>) => unknown,
+  <E>(self: Cause.Cause<E>, f: (error: E) => unknown) => unknown
+>(2, (self, f) => {
+  const option = pipe(self, internalCause.failureOption, Option.map(f))
+  switch (option._tag) {
+    case "None": {
+      return pipe(
+        internalCause.defects(self),
+        Chunk.head,
+        Option.match({
+          onNone: () => {
+            const interrupts = Array.from(internalCause.interruptors(self)).flatMap((fiberId) =>
+              Array.from(FiberId.ids(fiberId)).map((id) => `#${id}`)
+            )
+            return new InterruptedException(interrupts ? `Interrupted by fibers: ${interrupts.join(", ")}` : void 0)
+          },
+          onSome: identity
+        })
+      )
+    }
+    case "Some": {
+      return option.value
+    }
+  }
+})
+
+// -----------------------------------------------------------------------------
+// Errors
+// -----------------------------------------------------------------------------
+
+/** @internal */
+export const YieldableError: new(message?: string) => Cause.YieldableError = (function() {
+  class YieldableError extends globalThis.Error {
+    commit() {
+      return fail(this)
+    }
+    toString() {
+      return this.message ? `${this.name}: ${this.message}` : this.name
+    }
+    toJSON() {
+      return { ...this }
+    }
+    [NodeInspectSymbol](): string {
+      const stack = this.stack
+      if (stack) {
+        return `${this.toString()}\n${stack.split("\n").slice(1).join("\n")}`
+      }
+      return this.toString()
+    }
+  }
+  Object.assign(YieldableError.prototype, StructuralCommitPrototype)
+  return YieldableError as any
+})()
+
+const makeException = <T extends { _tag: string; message?: string }>(
+  proto: Omit<T, keyof Cause.YieldableError | "_tag">,
+  tag: T["_tag"]
+): new(message?: string | undefined) => T => {
+  class Base extends YieldableError {
+    readonly _tag = tag
+  }
+  Object.assign(Base.prototype, proto)
+  ;(Base.prototype as any).name = tag
+  return Base as any
+}
+
+/** @internal */
+export const RuntimeExceptionTypeId: Cause.RuntimeExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/RuntimeException"
+) as Cause.RuntimeExceptionTypeId
+
+/** @internal */
+export const RuntimeException = makeException<Cause.RuntimeException>({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException")
+
+/** @internal */
+export const isRuntimeException = (u: unknown): u is Cause.RuntimeException => hasProperty(u, RuntimeExceptionTypeId)
+
+/** @internal */
+export const InterruptedExceptionTypeId: Cause.InterruptedExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/InterruptedException"
+) as Cause.InterruptedExceptionTypeId
+
+/** @internal */
+export const InterruptedException = makeException<Cause.InterruptedException>({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException")
+
+/** @internal */
+export const isInterruptedException = (u: unknown): u is Cause.InterruptedException =>
+  hasProperty(u, InterruptedExceptionTypeId)
+
+/** @internal */
+export const IllegalArgumentExceptionTypeId: Cause.IllegalArgumentExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/IllegalArgument"
+) as Cause.IllegalArgumentExceptionTypeId
+
+/** @internal */
+export const IllegalArgumentException = makeException<Cause.IllegalArgumentException>({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException")
+
+/** @internal */
+export const isIllegalArgumentException = (u: unknown): u is Cause.IllegalArgumentException =>
+  hasProperty(u, IllegalArgumentExceptionTypeId)
+
+/** @internal */
+export const NoSuchElementExceptionTypeId: Cause.NoSuchElementExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/NoSuchElement"
+) as Cause.NoSuchElementExceptionTypeId
+
+/** @internal */
+export const NoSuchElementException = makeException<Cause.NoSuchElementException>({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException")
+
+/** @internal */
+export const isNoSuchElementException = (u: unknown): u is Cause.NoSuchElementException =>
+  hasProperty(u, NoSuchElementExceptionTypeId)
+
+/** @internal */
+export const InvalidPubSubCapacityExceptionTypeId: Cause.InvalidPubSubCapacityExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/InvalidPubSubCapacityException"
+) as Cause.InvalidPubSubCapacityExceptionTypeId
+
+/** @internal */
+export const InvalidPubSubCapacityException = makeException<Cause.InvalidPubSubCapacityException>({
+  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
+}, "InvalidPubSubCapacityException")
+
+/** @internal */
+export const isInvalidCapacityError = (u: unknown): u is Cause.InvalidPubSubCapacityException =>
+  hasProperty(u, InvalidPubSubCapacityExceptionTypeId)
+
+/** @internal */
+export const UnknownExceptionTypeId: Cause.UnknownExceptionTypeId = Symbol.for(
+  "effect/Cause/errors/UnknownException"
+) as Cause.UnknownExceptionTypeId
+
+/** @internal */
+export const UnknownException: new(error: unknown, message?: string | undefined) => Cause.UnknownException =
+  (function() {
+    class UnknownException extends YieldableError {
+      readonly _tag = "UnknownException"
+      constructor(readonly error: unknown, message?: string) {
+        super(message ?? (hasProperty(error, "message") && isString(error.message) ? error.message : void 0))
+      }
+    }
+    Object.assign(UnknownException.prototype, {
+      [UnknownExceptionTypeId]: UnknownExceptionTypeId,
+      name: "UnknownException"
+    })
+    return UnknownException as any
+  })()
+
+/** @internal */
+export const isUnknownException = (u: unknown): u is Cause.UnknownException => hasProperty(u, UnknownExceptionTypeId)
+
 // -----------------------------------------------------------------------------
 // Exit
 // -----------------------------------------------------------------------------
@@ -2142,16 +2348,18 @@ export const exitDie = (defect: unknown): Exit.Exit<never, never> =>
   exitFailCause(internalCause.die(defect)) as Exit.Exit<never, never>
 
 /** @internal */
-export const exitExists = dual<
-  <A>(predicate: Predicate<A>) => <E>(self: Exit.Exit<E, A>) => boolean,
-  <E, A>(self: Exit.Exit<E, A>, predicate: Predicate<A>) => boolean
->(2, (self, predicate) => {
+export const exitExists: {
+  <A, B extends A>(refinement: Refinement<A, B>): <E>(self: Exit.Exit<E, A>) => self is Exit.Exit<never, B>
+  <A>(predicate: Predicate<A>): <E>(self: Exit.Exit<E, A>) => boolean
+  <E, A, B extends A>(self: Exit.Exit<E, A>, refinement: Refinement<A, B>): self is Exit.Exit<never, B>
+  <E, A>(self: Exit.Exit<E, A>, predicate: Predicate<A>): boolean
+} = dual(2, <E, A, B extends A>(self: Exit.Exit<E, A>, refinement: Refinement<A, B>): self is Exit.Exit<never, B> => {
   switch (self._tag) {
     case OpCodes.OP_FAILURE: {
       return false
     }
     case OpCodes.OP_SUCCESS: {
-      return predicate(self.i0)
+      return refinement(self.i0)
     }
   }
 })