effect 3.0.5 → 3.0.7

package/src/STM.ts

@@ -14,8 +14,9 @@ import * as stm from "./internal/stm/stm.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
 import type { Predicate, Refinement } from "./Predicate.js"
-import type { Covariant, MergeRecord } from "./Types.js"
+import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
+import type { YieldWrap } from "./Utils.js"
 
 /**
  * @since 2.0.0
@@ -1064,12 +1065,12 @@ export interface Adapter {
  * @since 2.0.0
  * @category constructors
  */
-export const gen: <Eff extends STM<any, any, any>, AEff>(
+export const gen: <Eff extends YieldWrap<STM<any, any, any>>, AEff>(
   f: (resume: Adapter) => Generator<Eff, AEff, never>
 ) => STM<
   AEff,
-  [Eff] extends [never] ? never : [Eff] extends [STM<infer _A, infer E, infer _R>] ? E : never,
-  [Eff] extends [never] ? never : [Eff] extends [STM<infer _A, infer _E, infer R>] ? R : never
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<STM<infer _A, infer E, infer _R>>] ? E : never,
+  [Eff] extends [never] ? never : [Eff] extends [YieldWrap<STM<infer _A, infer _E, infer R>>] ? R : never
 > = stm.gen
 
 /**

package/src/SortedSet.ts

@@ -14,7 +14,7 @@ import { pipeArguments } from "./Pipeable.js"
 import type { Predicate } from "./Predicate.js"
 import { hasProperty } from "./Predicate.js"
 import * as RBT from "./RedBlackTree.js"
-import type { Invariant } from "./Types.js"
+import type { Invariant, NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = Symbol.for("effect/SortedSet")
 

package/src/Stream.ts

@@ -29,7 +29,7 @@ import type * as Emit from "./StreamEmit.js"
 import type * as HaltStrategy from "./StreamHaltStrategy.js"
 import type * as Take from "./Take.js"
 import type * as Tracer from "./Tracer.js"
-import type { Covariant, MergeRecord } from "./Types.js"
+import type { Covariant, MergeRecord, NoInfer } from "./Types.js"
 import type * as Unify from "./Unify.js"
 
 /**

package/src/Subscribable.ts

@@ -7,6 +7,7 @@ import { pipeArguments } from "./Pipeable.js"
 import { hasProperty } from "./Predicate.js"
 import * as Readable from "./Readable.js"
 import * as Stream from "./Stream.js"
+import type { NoInfer } from "./Types.js"
 
 /**
  * @since 2.0.0

package/src/Trie.ts

@@ -20,7 +20,7 @@ import type { Inspectable } from "./Inspectable.js"
 import * as TR from "./internal/trie.js"
 import type { Option } from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
-import type { Covariant } from "./Types.js"
+import type { Covariant, NoInfer } from "./Types.js"
 
 const TypeId: unique symbol = TR.TrieTypeId as TypeId
 

package/src/Types.ts

@@ -170,6 +170,14 @@ export type Mutable<T> = {
   -readonly [P in keyof T]: T[P]
 }
 
+/**
+ * Avoid inference on a specific parameter
+ *
+ * @since 2.0.0
+ * @category models
+ */
+export type NoInfer<A> = [A][A extends any ? 0 : never]
+
 /**
  * Invariant helper.
  *

package/src/Utils.ts

@@ -3,7 +3,8 @@
  */
 import { identity } from "./Function.js"
 import type { Kind, TypeLambda } from "./HKT.js"
-import { isNullable } from "./Predicate.js"
+import { getBugErrorMessage } from "./internal/errors.js"
+import { isNullable, isObject } from "./Predicate.js"
 import type * as Types from "./Types.js"
 
 /*
@@ -41,6 +42,12 @@ export interface GenKind<F extends TypeLambda, R, O, E, A> extends Variance<F, R
   [Symbol.iterator](): Generator<GenKind<F, R, O, E, A>, A>
 }
 
+/**
+ * @category predicates
+ * @since 3.0.6
+ */
+export const isGenKind = (u: unknown): u is GenKind<any, any, any, any, any> => isObject(u) && GenKindTypeId in u
+
 /**
  * @category constructors
  * @since 2.0.0
@@ -173,13 +180,19 @@ export interface Variance<in out F extends TypeLambda, in R, out O, out E> {
  * @since 2.0.0
  */
 export interface Gen<F extends TypeLambda, Z> {
-  <K extends Variance<F, any, any, any> | Kind<F, any, any, any, any>, A>(
+  <K extends Variance<F, any, any, any> | YieldWrap<Kind<F, any, any, any, any>>, A>(
     body: (resume: Z) => Generator<K, A, never>
   ): Kind<
     F,
-    [K] extends [Variance<F, infer R, any, any>] ? R : [K] extends [Kind<F, infer R, any, any, any>] ? R : never,
-    [K] extends [Variance<F, any, infer O, any>] ? O : [K] extends [Kind<F, any, infer O, any, any>] ? O : never,
-    [K] extends [Variance<F, any, any, infer E>] ? E : [K] extends [Kind<F, any, any, infer E, any>] ? E : never,
+    [K] extends [Variance<F, infer R, any, any>] ? R
+      : [K] extends [YieldWrap<Kind<F, infer R, any, any, any>>] ? R
+      : never,
+    [K] extends [Variance<F, any, infer O, any>] ? O
+      : [K] extends [YieldWrap<Kind<F, any, infer O, any, any>>] ? O
+      : never,
+    [K] extends [Variance<F, any, any, infer E>] ? E
+      : [K] extends [YieldWrap<Kind<F, any, any, infer E, any>>] ? E
+      : never,
     A
   >
 }
@@ -191,22 +204,22 @@ export interface Gen<F extends TypeLambda, Z> {
 export interface Adapter<Z extends TypeLambda> {
   <_R, _O, _E, _A>(
     self: Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
-  <A, _R, _O, _E, _A>(a: A, ab: (a: A) => Kind<Z, _R, _O, _E, _A>): Kind<Z, _R, _O, _E, _A>
-  <A, B, _R, _O, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => Kind<Z, _R, _O, _E, _A>): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
+  <A, _R, _O, _E, _A>(a: A, ab: (a: A) => Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>
+  <A, B, _R, _O, _E, _A>(a: A, ab: (a: A) => B, bc: (b: B) => Kind<Z, _R, _O, _E, _A>): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
     bc: (b: B) => C,
     cd: (c: C) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
     bc: (b: B) => C,
     cd: (c: C) => D,
     de: (d: D) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -214,7 +227,7 @@ export interface Adapter<Z extends TypeLambda> {
     cd: (c: C) => D,
     de: (d: D) => E,
     ef: (e: E) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -223,7 +236,7 @@ export interface Adapter<Z extends TypeLambda> {
     de: (d: D) => E,
     ef: (e: E) => F,
     fg: (f: F) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -233,7 +246,7 @@ export interface Adapter<Z extends TypeLambda> {
     ef: (e: E) => F,
     fg: (f: F) => G,
     gh: (g: F) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -244,7 +257,7 @@ export interface Adapter<Z extends TypeLambda> {
     fg: (f: F) => G,
     gh: (g: G) => H,
     hi: (g: H) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -256,7 +269,7 @@ export interface Adapter<Z extends TypeLambda> {
     gh: (g: G) => H,
     hi: (h: H) => I,
     ij: (i: I) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -269,7 +282,7 @@ export interface Adapter<Z extends TypeLambda> {
     hi: (h: H) => I,
     ij: (i: I) => J,
     jk: (j: J) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -283,7 +296,7 @@ export interface Adapter<Z extends TypeLambda> {
     ij: (i: I) => J,
     jk: (j: J) => K,
     kl: (k: K) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -298,7 +311,7 @@ export interface Adapter<Z extends TypeLambda> {
     jk: (j: J) => K,
     kl: (k: K) => L,
     lm: (l: L) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -314,7 +327,7 @@ export interface Adapter<Z extends TypeLambda> {
     kl: (k: K) => L,
     lm: (l: L) => M,
     mn: (m: M) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -331,7 +344,7 @@ export interface Adapter<Z extends TypeLambda> {
     lm: (l: L) => M,
     mn: (m: M) => N,
     no: (n: N) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -349,7 +362,7 @@ export interface Adapter<Z extends TypeLambda> {
     mn: (m: M) => N,
     no: (n: N) => O,
     op: (o: O) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -368,7 +381,7 @@ export interface Adapter<Z extends TypeLambda> {
     no: (n: N) => O,
     op: (o: O) => P,
     pq: (p: P) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -388,7 +401,7 @@ export interface Adapter<Z extends TypeLambda> {
     op: (o: O) => P,
     pq: (p: P) => Q,
     qr: (q: Q) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -409,7 +422,7 @@ export interface Adapter<Z extends TypeLambda> {
     pq: (p: P) => Q,
     qr: (q: Q) => R,
     rs: (r: R) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -431,7 +444,7 @@ export interface Adapter<Z extends TypeLambda> {
     qr: (q: Q) => R,
     rs: (r: R) => S,
     st: (s: S) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
   <A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, _R, _O, _E, _A>(
     a: A,
     ab: (a: A) => B,
@@ -454,7 +467,7 @@ export interface Adapter<Z extends TypeLambda> {
     rs: (r: R) => S,
     st: (s: S) => T,
     tu: (s: T) => Kind<Z, _R, _O, _E, _A>
-  ): Kind<Z, _R, _O, _E, _A>
+  ): GenKind<Z, _R, _O, _E, _A>
 }
 
 /**
@@ -466,7 +479,7 @@ export const adapter: <F extends TypeLambda>() => Adapter<F> = () => (function()
   for (let i = 1; i < arguments.length; i++) {
     x = arguments[i](x)
   }
-  return x
+  return new GenKindImpl(x) as any
 })
 
 const defaultIncHi = 0x14057b7e
@@ -699,3 +712,37 @@ function add64(
   out[0] = hi
   out[1] = lo
 }
+
+/**
+ * @since 3.0.6
+ */
+export const YieldWrapTypeId = Symbol.for("effect/Utils/YieldWrap")
+
+/**
+ * @since 3.0.6
+ */
+export class YieldWrap<T> {
+  /**
+   * @since 3.0.6
+   */
+  readonly #value: T
+  constructor(value: T) {
+    this.#value = value
+  }
+  /**
+   * @since 3.0.6
+   */
+  [YieldWrapTypeId](): T {
+    return this.#value
+  }
+}
+
+/**
+ * @since 3.0.6
+ */
+export function yieldWrapGet<T>(self: YieldWrap<T>): T {
+  if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
+    return self[YieldWrapTypeId]()
+  }
+  throw new Error(getBugErrorMessage("yieldWrapGet"))
+}

package/src/internal/cause.ts

@@ -13,6 +13,7 @@ import { pipeArguments } from "../Pipeable.js"
 import { hasProperty, isFunction } from "../Predicate.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import type { AnySpan, Span } from "../Tracer.js"
+import type { NoInfer } from "../Types.js"
 import { getBugErrorMessage } from "./errors.js"
 import * as OpCodes from "./opCodes/cause.js"
 

package/src/internal/core-effect.ts

@@ -25,7 +25,8 @@ import type * as Random from "../Random.js"
 import * as Ref from "../Ref.js"
 import type * as runtimeFlagsPatch from "../RuntimeFlagsPatch.js"
 import * as Tracer from "../Tracer.js"
-import type { MergeRecord } from "../Types.js"
+import type { MergeRecord, NoInfer } from "../Types.js"
+import { yieldWrapGet } from "../Utils.js"
 import * as internalCause from "./cause.js"
 import { clockTag } from "./clock.js"
 import * as core from "./core.js"
@@ -788,9 +789,11 @@ export const gen: typeof Effect.gen = function() {
     const state = iterator.next()
     const run = (
       state: IteratorYieldResult<any> | IteratorReturnResult<any>
-    ): Effect.Effect<any, any, any> => (state.done
-      ? core.succeed(state.value)
-      : core.flatMap(state.value, (val: any) => run(iterator.next(val))))
+    ): Effect.Effect<any, any, any> => {
+      return (state.done
+        ? core.succeed(state.value)
+        : core.flatMap(yieldWrapGet(state.value) as any, (val: any) => run(iterator.next(val))))
+    }
     return run(state)
   })
 }

package/src/internal/core.ts

@@ -35,7 +35,8 @@ 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 { NotFunction } from "../Types.js"
+import type { NoInfer, NotFunction } from "../Types.js"
+import { YieldWrap } from "../Utils.js"
 import * as _blockedRequests from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as deferred from "./deferred.js"
@@ -180,7 +181,7 @@ class EffectPrimitive {
     return this.toJSON()
   }
   [Symbol.iterator]() {
-    return new SingleShotGen(this)
+    return new SingleShotGen(new YieldWrap(this))
   }
 }
 
@@ -221,7 +222,7 @@ class EffectPrimitiveFailure {
     return this.toJSON()
   }
   [Symbol.iterator]() {
-    return new SingleShotGen(this)
+    return new SingleShotGen(new YieldWrap(this))
   }
 }
 
@@ -262,7 +263,7 @@ class EffectPrimitiveSuccess {
     return this.toJSON()
   }
   [Symbol.iterator]() {
-    return new SingleShotGen(this)
+    return new SingleShotGen(new YieldWrap(this))
   }
 }
 

package/src/internal/dataSource.ts

@@ -7,6 +7,7 @@ import type * as Either from "../Either.js"
 import { dual, pipe } from "../Function.js"
 import type * as Request from "../Request.js"
 import type * as RequestResolver from "../RequestResolver.js"
+import type { NoInfer } from "../Types.js"
 import * as core from "./core.js"
 import { invokeWithInterrupt, zipWithOptions } from "./fiberRuntime.js"
 import { complete } from "./request.js"
@@ -24,21 +25,21 @@ export const makeWithEntry = <A, R>(
 
 /** @internal */
 export const makeBatched = <A extends Request.Request<any, any>, R>(
-  run: (requests: Array<A>) => Effect.Effect<void, never, R>
+  run: (requests: RA.NonEmptyArray<A>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> =>
   new core.RequestResolverImpl<A, R>(
     (requests) => {
       if (requests.length > 1) {
         return core.forEachSequentialDiscard(requests, (block) => {
           const filtered = block.filter((_) => !_.state.completed).map((_) => _.request)
-          if (filtered.length === 0) {
+          if (!RA.isNonEmptyArray(filtered)) {
             return core.void
           }
           return invokeWithInterrupt(run(filtered), block)
         })
       } else if (requests.length === 1) {
         const filtered = requests[0].filter((_) => !_.state.completed).map((_) => _.request)
-        if (filtered.length === 0) {
+        if (!RA.isNonEmptyArray(filtered)) {
           return core.void
         }
         return run(filtered)
@@ -210,7 +211,7 @@ export const eitherWith = dual<
 export const fromFunction = <A extends Request.Request<any>>(
   f: (request: A) => Request.Request.Success<A>
 ): RequestResolver.RequestResolver<A> =>
-  makeBatched((requests: Array<A>) =>
+  makeBatched((requests: RA.NonEmptyArray<A>) =>
     core.forEachSequentialDiscard(
       requests,
       (request) => complete(request, core.exitSucceed(f(request)) as any)
@@ -219,9 +220,9 @@ export const fromFunction = <A extends Request.Request<any>>(
 
 /** @internal */
 export const fromFunctionBatched = <A extends Request.Request<any>>(
-  f: (chunk: Array<A>) => Iterable<Request.Request.Success<A>>
+  f: (chunk: RA.NonEmptyArray<A>) => Iterable<Request.Request.Success<A>>
 ): RequestResolver.RequestResolver<A> =>
-  makeBatched((as: Array<A>) =>
+  makeBatched((as: RA.NonEmptyArray<A>) =>
     Effect.forEach(
       f(as),
       (res, i) => complete(as[i], core.exitSucceed(res) as any),
@@ -233,7 +234,7 @@ export const fromFunctionBatched = <A extends Request.Request<any>>(
 export const fromEffect = <R, A extends Request.Request<any, any>>(
   f: (a: A) => Effect.Effect<Request.Request.Success<A>, Request.Request.Error<A>, R>
 ): RequestResolver.RequestResolver<A, R> =>
-  makeBatched((requests: Array<A>) =>
+  makeBatched((requests: RA.NonEmptyArray<A>) =>
     Effect.forEach(
       requests,
       (a) => Effect.flatMap(Effect.exit(f(a)), (e) => complete(a, e as any)),
@@ -261,7 +262,7 @@ export const fromEffectTagged = <
   A,
   ReturnType<Fns[keyof Fns]> extends Effect.Effect<infer _A, infer _E, infer R> ? R : never
 > =>
-  makeBatched<A, any>((requests: Array<A>) => {
+  makeBatched<A, any>((requests: RA.NonEmptyArray<A>) => {
     const grouped: Record<string, Array<A>> = {}
     const tags: Array<A["_tag"]> = []
     for (let i = 0, len = requests.length; i < len; i++) {

package/src/internal/effectable.ts

@@ -6,8 +6,8 @@ import * as Hash from "../Hash.js"
 import { pipeArguments } from "../Pipeable.js"
 import type * as Sink from "../Sink.js"
 import type * as Stream from "../Stream.js"
+import { SingleShotGen, YieldWrap } from "../Utils.js"
 import * as OpCodes from "./opCodes/effect.js"
-import * as SingleShotGen from "./singleShotGen.js"
 import * as version from "./version.js"
 
 /** @internal */
@@ -77,7 +77,7 @@ export const EffectPrototype: Effect.Effect<never> & Equal.Equal = {
     return Hash.cached(this, Hash.random(this))
   },
   [Symbol.iterator]() {
-    return new SingleShotGen.SingleShotGen(this) as any
+    return new SingleShotGen(new YieldWrap(this)) as any
   },
   pipe() {
     return pipeArguments(this, arguments)

package/src/internal/fiberRuntime.ts

@@ -41,7 +41,7 @@ import { currentScheduler, type Scheduler } from "../Scheduler.js"
 import type * as Scope from "../Scope.js"
 import type * as Supervisor from "../Supervisor.js"
 import type * as Tracer from "../Tracer.js"
-import type { Concurrency } from "../Types.js"
+import type { Concurrency, NoInfer } from "../Types.js"
 import * as _RequestBlock from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as clock from "./clock.js"
@@ -3518,9 +3518,26 @@ export const invokeWithInterrupt: <A, E, R>(
             const counts = entries.map((_) => _.listeners.count)
             const checkDone = () => {
               if (counts.every((count) => count === 0)) {
-                cleanup.forEach((f) => f())
-                onInterrupt?.()
-                cb(core.interruptFiber(processing))
+                if (
+                  entries.every((_) => {
+                    if (_.result.state.current._tag === "Pending") {
+                      return true
+                    } else if (
+                      _.result.state.current._tag === "Done" &&
+                      core.exitIsExit(_.result.state.current.effect) &&
+                      _.result.state.current.effect._tag === "Failure" &&
+                      internalCause.isInterrupted(_.result.state.current.effect.cause)
+                    ) {
+                      return true
+                    } else {
+                      return false
+                    }
+                  })
+                ) {
+                  cleanup.forEach((f) => f())
+                  onInterrupt?.()
+                  cb(core.interruptFiber(processing))
+                }
               }
             }
             processing.addObserver((exit) => {

package/src/internal/groupBy.ts

@@ -13,7 +13,7 @@ import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
 import type * as Stream from "../Stream.js"
 import type * as Take from "../Take.js"
-import type { MergeRecord } from "../Types.js"
+import type { MergeRecord, NoInfer } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as core from "./core-stream.js"

package/src/internal/hashMap.ts

@@ -7,6 +7,7 @@ import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
+import type { NoInfer } from "../Types.js"
 import { fromBitmap, hashFragment, toBitmap } from "./hashMap/bitwise.js"
 import { SIZE } from "./hashMap/config.js"
 import * as Node from "./hashMap/node.js"

package/src/internal/hashSet.ts

@@ -7,6 +7,7 @@ import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import { hasProperty } from "../Predicate.js"
+import type { NoInfer } from "../Types.js"
 import * as HM from "./hashMap.js"
 
 const HashSetSymbolKey = "effect/HashSet"

package/src/internal/schedule.ts

@@ -18,6 +18,7 @@ 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 type * as Types from "../Types.js"
 import * as internalCause from "./cause.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
@@ -1902,7 +1903,7 @@ export const retry_combined: {
     self: Effect.Effect<A, E, R>
   ) => Effect.Retry.Return<R, E, A, O>
   <B, E, R1>(
-    policy: Schedule.Schedule<B, NoInfer<E>, R1>
+    policy: Schedule.Schedule<B, Types.NoInfer<E>, R1>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R1 | R>
   <A, E, R, O extends Effect.Retry.Options<E>>(
     self: Effect.Effect<A, E, R>,
@@ -1948,13 +1949,13 @@ export const retry_combined: {
 /** @internal */
 export const retryOrElse_Effect = dual<
   <A1, E, R1, A2, E2, R2>(
-    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
-    orElse: (e: NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
+    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
+    orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2, R | R1 | R2>,
   <A, E, R, A1, R1, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
-    orElse: (e: NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
+    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
+    orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => Effect.Effect<A | A2, E2, R | R1 | R2>
 >(3, (self, policy, orElse) =>
   core.flatMap(

package/src/internal/stm/core.ts

@@ -15,6 +15,7 @@ import { hasProperty } from "../../Predicate.js"
 import type * as Scheduler from "../../Scheduler.js"
 import type * as STM from "../../STM.js"
 import { StreamTypeId } from "../../Stream.js"
+import { YieldWrap } from "../../Utils.js"
 import { ChannelTypeId } from "../core-stream.js"
 import { withFiberRuntime } from "../core.js"
 import { effectVariance } from "../effectable.js"
@@ -172,7 +173,7 @@ class STMPrimitive implements STM.STM<any, any, any> {
     return Hash.cached(this, Hash.random(this))
   }
   [Symbol.iterator]() {
-    return new SingleShotGen(this) as any
+    return new SingleShotGen(new YieldWrap(this)) as any
   }
   commit(this: STM.STM<any, any, any>): Effect.Effect<any, any, any> {
     return unsafeAtomically(this, constVoid, constVoid)

package/src/internal/stm/stm.ts

@@ -12,7 +12,8 @@ import * as Option from "../../Option.js"
 import type { Predicate, Refinement } from "../../Predicate.js"
 import * as predicate from "../../Predicate.js"
 import type * as STM from "../../STM.js"
-import type { MergeRecord } from "../../Types.js"
+import type { MergeRecord, NoInfer } from "../../Types.js"
+import { yieldWrapGet } from "../../Utils.js"
 import * as effectCore from "../core.js"
 import * as core from "./core.js"
 import * as Journal from "./stm/journal.js"
@@ -626,7 +627,7 @@ export const gen: typeof STM.gen = (f) =>
     ): STM.STM<any, any, any> =>
       state.done ?
         core.succeed(state.value) :
-        core.flatMap(state.value, (val: any) => run(iterator.next(val as never)))
+        core.flatMap(yieldWrapGet(state.value) as any, (val: any) => run(iterator.next(val as never)))
     return run(state)
   })
 

package/src/internal/stream.ts

@@ -31,7 +31,7 @@ import * as HaltStrategy from "../StreamHaltStrategy.js"
 import type * as Take from "../Take.js"
 import type * as Tracer from "../Tracer.js"
 import * as Tuple from "../Tuple.js"
-import type { MergeRecord } from "../Types.js"
+import type { MergeRecord, NoInfer } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as MergeStrategy from "./channel/mergeStrategy.js"