effect 3.6.7 → 3.7.0

package/src/FiberHandle.ts

@@ -10,7 +10,8 @@ import * as Exit from "./Exit.js"
 import * as Fiber from "./Fiber.js"
 import * as FiberId from "./FiberId.js"
 import * as FiberRef from "./FiberRef.js"
-import { dual } from "./Function.js"
+import { constFalse, dual } from "./Function.js"
+import * as HashSet from "./HashSet.js"
 import * as Inspectable from "./Inspectable.js"
 import type { FiberRuntime } from "./internal/fiberRuntime.js"
 import * as Option from "./Option.js"
@@ -142,6 +143,17 @@ export const makeRuntime = <R, E = unknown, A = unknown>(): Effect.Effect<
     (self) => runtime(self)<R>()
   )
 
+const internalFiberIdId = -1
+const internalFiberId = FiberId.make(internalFiberIdId, 0)
+const isInternalInterruption = Cause.reduceWithContext(undefined, {
+  emptyCase: constFalse,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), internalFiberIdId),
+  sequentialCase: (_, left, right) => left || right,
+  parallelCase: (_, left, right) => left || right
+})
+
 /**
  * Set the fiber in a FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
  * If a fiber is already running, it will be interrupted unless `options.onlyIfMissing` is set.
@@ -155,6 +167,7 @@ export const unsafeSet: {
     options?: {
       readonly interruptAs?: FiberId.FiberId | undefined
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     }
   ): (self: FiberHandle<A, E>) => void
   <A, E, XE extends E, XA extends A>(
@@ -163,6 +176,7 @@ export const unsafeSet: {
     options?: {
       readonly interruptAs?: FiberId.FiberId | undefined
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     }
   ): void
 } = dual((args) => isFiberHandle(args[0]), <A, E, XE extends E, XA extends A>(
@@ -171,19 +185,20 @@ export const unsafeSet: {
   options?: {
     readonly interruptAs?: FiberId.FiberId | undefined
     readonly onlyIfMissing?: boolean | undefined
+    readonly propagateInterruption?: boolean | undefined
   }
 ): void => {
   if (self.state._tag === "Closed") {
-    fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+    fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
     return
   } else if (self.state.fiber !== undefined) {
     if (options?.onlyIfMissing === true) {
-      fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+      fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
       return
     } else if (self.state.fiber === fiber) {
       return
     }
-    self.state.fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+    self.state.fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
     self.state.fiber = undefined
   }
 
@@ -193,7 +208,14 @@ export const unsafeSet: {
     if (self.state._tag === "Open" && fiber === self.state.fiber) {
       self.state.fiber = undefined
     }
-    if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+    if (
+      Exit.isFailure(exit) &&
+      (
+        options?.propagateInterruption === true ?
+          !isInternalInterruption(exit.cause) :
+          !Cause.isInterruptedOnly(exit.cause)
+      )
+    ) {
       Deferred.unsafeDone(self.deferred, exit as any)
     }
   })
@@ -211,6 +233,7 @@ export const set: {
     fiber: Fiber.RuntimeFiber<XA, XE>,
     options?: {
       readonly onlyIfMissing?: boolean
+      readonly propagateInterruption?: boolean | undefined
     }
   ): (self: FiberHandle<A, E>) => Effect.Effect<void>
   <A, E, XE extends E, XA extends A>(
@@ -218,6 +241,7 @@ export const set: {
     fiber: Fiber.RuntimeFiber<XA, XE>,
     options?: {
       readonly onlyIfMissing?: boolean
+      readonly propagateInterruption?: boolean | undefined
     }
   ): Effect.Effect<void>
 } = dual((args) => isFiberHandle(args[0]), <A, E, XE extends E, XA extends A>(
@@ -225,6 +249,7 @@ export const set: {
   fiber: Fiber.RuntimeFiber<XA, XE>,
   options?: {
     readonly onlyIfMissing?: boolean
+    readonly propagateInterruption?: boolean | undefined
   }
 ): Effect.Effect<void> =>
   Effect.fiberIdWith(
@@ -232,7 +257,8 @@ export const set: {
       Effect.sync(() =>
         unsafeSet(self, fiber, {
           interruptAs: fiberId,
-          onlyIfMissing: options?.onlyIfMissing
+          onlyIfMissing: options?.onlyIfMissing,
+          propagateInterruption: options?.propagateInterruption
         })
       )
   ))
@@ -261,12 +287,12 @@ export const get = <A, E>(self: FiberHandle<A, E>): Effect.Effect<Fiber.RuntimeF
  */
 export const clear = <A, E>(self: FiberHandle<A, E>): Effect.Effect<void> =>
   Effect.uninterruptibleMask((restore) =>
-    Effect.suspend(() => {
+    Effect.withFiberRuntime((fiber) => {
       if (self.state._tag === "Closed" || self.state.fiber === undefined) {
         return Effect.void
       }
       return Effect.zipRight(
-        restore(Fiber.interrupt(self.state.fiber)),
+        restore(Fiber.interruptAs(self.state.fiber, FiberId.combine(fiber.id(), internalFiberId))),
         Effect.sync(() => {
           if (self.state._tag === "Open") {
             self.state.fiber = undefined
@@ -298,6 +324,7 @@ export const run: {
     self: FiberHandle<A, E>,
     options?: {
       readonly onlyIfMissing?: boolean
+      readonly propagateInterruption?: boolean | undefined
     }
   ): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>
@@ -307,13 +334,17 @@ export const run: {
     effect: Effect.Effect<XA, XE, R>,
     options?: {
       readonly onlyIfMissing?: boolean
+      readonly propagateInterruption?: boolean | undefined
     }
   ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
   const self = arguments[0] as FiberHandle
   if (Effect.isEffect(arguments[1])) {
     const effect = arguments[1]
-    const options = arguments[2] as { readonly onlyIfMissing?: boolean } | undefined
+    const options = arguments[2] as {
+      readonly onlyIfMissing?: boolean
+      readonly propagateInterruption?: boolean | undefined
+    } | undefined
     return Effect.suspend(() => {
       if (self.state._tag === "Closed") {
         return Effect.interrupt
@@ -328,7 +359,10 @@ export const run: {
       )
     }) as any
   }
-  const options = arguments[1] as { readonly onlyIfMissing?: boolean } | undefined
+  const options = arguments[1] as {
+    readonly onlyIfMissing?: boolean
+    readonly propagateInterruption?: boolean | undefined
+  } | undefined
   return (effect: Effect.Effect<unknown, unknown, any>) =>
     Effect.suspend(() => {
       if (self.state._tag === "Closed") {
@@ -382,6 +416,7 @@ export const runtime: <A, E>(
     options?:
       | Runtime.RunForkOptions & {
         readonly onlyIfMissing?: boolean | undefined
+        readonly propagateInterruption?: boolean | undefined
       }
       | undefined
   ) => Fiber.RuntimeFiber<XA, XE>,
@@ -397,6 +432,7 @@ export const runtime: <A, E>(
         options?:
           | Runtime.RunForkOptions & {
             readonly onlyIfMissing?: boolean | undefined
+            readonly propagateInterruption?: boolean | undefined
           }
           | undefined
       ) => {

package/src/FiberMap.ts

@@ -10,7 +10,8 @@ import * as Exit from "./Exit.js"
 import * as Fiber from "./Fiber.js"
 import * as FiberId from "./FiberId.js"
 import * as FiberRef from "./FiberRef.js"
-import { dual } from "./Function.js"
+import { constFalse, dual } from "./Function.js"
+import * as HashSet from "./HashSet.js"
 import * as Inspectable from "./Inspectable.js"
 import type { FiberRuntime } from "./internal/fiberRuntime.js"
 import * as Iterable from "./Iterable.js"
@@ -157,6 +158,17 @@ export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
     (self) => runtime(self)<R>()
   )
 
+const internalFiberIdId = -1
+const internalFiberId = FiberId.make(internalFiberIdId, 0)
+const isInternalInterruption = Cause.reduceWithContext(undefined, {
+  emptyCase: constFalse,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), internalFiberIdId),
+  sequentialCase: (_, left, right) => left || right,
+  parallelCase: (_, left, right) => left || right
+})
+
 /**
  * Add a fiber to the FiberMap. When the fiber completes, it will be removed from the FiberMap.
  * If the key already exists in the FiberMap, the previous fiber will be interrupted.
@@ -171,6 +183,7 @@ export const unsafeSet: {
     options?: {
       readonly interruptAs?: FiberId.FiberId | undefined
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): (self: FiberMap<K, A, E>) => void
   <K, A, E, XE extends E, XA extends A>(
@@ -180,6 +193,7 @@ export const unsafeSet: {
     options?: {
       readonly interruptAs?: FiberId.FiberId | undefined
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): void
 } = dual((args) => isFiberMap(args[0]), <K, A, E, XE extends E, XA extends A>(
@@ -189,22 +203,23 @@ export const unsafeSet: {
   options?: {
     readonly interruptAs?: FiberId.FiberId | undefined
     readonly onlyIfMissing?: boolean | undefined
+    readonly propagateInterruption?: boolean | undefined
   } | undefined
 ): void => {
   if (self.state._tag === "Closed") {
-    fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+    fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
     return
   }
 
   const previous = MutableHashMap.get(self.state.backing, key)
   if (previous._tag === "Some") {
     if (options?.onlyIfMissing === true) {
-      fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+      fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
       return
     } else if (previous.value === fiber) {
       return
     }
-    previous.value.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+    previous.value.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
   }
 
   ;(fiber as FiberRuntime<unknown, unknown>).setFiberRef(FiberRef.unhandledErrorLogLevel, Option.none())
@@ -217,7 +232,14 @@ export const unsafeSet: {
     if (Option.isSome(current) && fiber === current.value) {
       MutableHashMap.remove(self.state.backing, key)
     }
-    if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+    if (
+      Exit.isFailure(exit) &&
+      (
+        options?.propagateInterruption === true ?
+          !isInternalInterruption(exit.cause) :
+          !Cause.isInterruptedOnly(exit.cause)
+      )
+    ) {
       Deferred.unsafeDone(self.deferred, exit as any)
     }
   })
@@ -236,6 +258,7 @@ export const set: {
     fiber: Fiber.RuntimeFiber<XA, XE>,
     options?: {
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): (self: FiberMap<K, A, E>) => Effect.Effect<void>
   <K, A, E, XE extends E, XA extends A>(
@@ -244,6 +267,7 @@ export const set: {
     fiber: Fiber.RuntimeFiber<XA, XE>,
     options?: {
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): Effect.Effect<void>
 } = dual((args) => isFiberMap(args[0]), <K, A, E, XE extends E, XA extends A>(
@@ -252,14 +276,15 @@ export const set: {
   fiber: Fiber.RuntimeFiber<XA, XE>,
   options?: {
     readonly onlyIfMissing?: boolean | undefined
+    readonly propagateInterruption?: boolean | undefined
   } | undefined
 ): Effect.Effect<void> =>
   Effect.fiberIdWith(
     (fiberId) =>
       Effect.sync(() =>
         unsafeSet(self, key, fiber, {
-          interruptAs: fiberId,
-          onlyIfMissing: options?.onlyIfMissing
+          ...options,
+          interruptAs: fiberId
         })
       )
   ))
@@ -349,7 +374,7 @@ export const remove: {
     key: K
   ) => Effect.Effect<void>
 >(2, (self, key) =>
-  Effect.suspend(() => {
+  Effect.withFiberRuntime((removeFiber) => {
     if (self.state._tag === "Closed") {
       return Effect.void
     }
@@ -358,7 +383,7 @@ export const remove: {
       return Effect.void
     }
     // will be removed by the observer
-    return Fiber.interrupt(fiber.value)
+    return Fiber.interruptAs(fiber.value, FiberId.combine(removeFiber.id(), internalFiberId))
   }))
 
 /**
@@ -366,14 +391,14 @@ export const remove: {
  * @categories combinators
  */
 export const clear = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<void> =>
-  Effect.suspend(() => {
+  Effect.withFiberRuntime((clearFiber) => {
     if (self.state._tag === "Closed") {
       return Effect.void
     }
 
     return Effect.forEach(self.state.backing, ([, fiber]) =>
       // will be removed by the observer
-      Fiber.interrupt(fiber))
+      Fiber.interruptAs(fiber, FiberId.combine(clearFiber.id(), internalFiberId)))
   })
 
 const constInterruptedFiber = (function() {
@@ -399,6 +424,7 @@ export const run: {
     key: K,
     options?: {
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>
@@ -409,6 +435,7 @@ export const run: {
     effect: Effect.Effect<XA, XE, R>,
     options?: {
       readonly onlyIfMissing?: boolean | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
@@ -416,7 +443,10 @@ export const run: {
     const self = arguments[0] as FiberMap<any>
     const key = arguments[1]
     const effect = arguments[2] as Effect.Effect<any, any, any>
-    const options = arguments[3] as { readonly onlyIfMissing?: boolean } | undefined
+    const options = arguments[3] as {
+      readonly onlyIfMissing?: boolean
+      readonly propagateInterruption?: boolean | undefined
+    } | undefined
     return Effect.suspend(() => {
       if (self.state._tag === "Closed") {
         return Effect.interrupt
@@ -433,7 +463,10 @@ export const run: {
   }
   const self = arguments[0] as FiberMap<any>
   const key = arguments[1]
-  const options = arguments[2] as { readonly onlyIfMissing?: boolean } | undefined
+  const options = arguments[2] as {
+    readonly onlyIfMissing?: boolean
+    readonly propagateInterruption?: boolean | undefined
+  } | undefined
   return (effect: Effect.Effect<any, any, any>) =>
     Effect.suspend(() => {
       if (self.state._tag === "Closed") {
@@ -486,6 +519,7 @@ export const runtime: <K, A, E>(
     options?:
       | Runtime.RunForkOptions & {
         readonly onlyIfMissing?: boolean | undefined
+        readonly propagateInterruption?: boolean | undefined
       }
       | undefined
   ) => Fiber.RuntimeFiber<XA, XE>,
@@ -502,6 +536,7 @@ export const runtime: <K, A, E>(
         options?:
           | Runtime.RunForkOptions & {
             readonly onlyIfMissing?: boolean | undefined
+            readonly propagateInterruption?: boolean | undefined
           }
           | undefined
       ) => {

package/src/FiberSet.ts

@@ -9,7 +9,8 @@ import * as Deferred from "./Deferred.js"
 import * as Exit from "./Exit.js"
 import * as Fiber from "./Fiber.js"
 import * as FiberRef from "./FiberRef.js"
-import { dual } from "./Function.js"
+import { constFalse, dual } from "./Function.js"
+import * as HashSet from "./HashSet.js"
 import * as Inspectable from "./Inspectable.js"
 import type { FiberRuntime } from "./internal/fiberRuntime.js"
 import * as Iterable from "./Iterable.js"
@@ -146,6 +147,17 @@ export const makeRuntime = <R = never, A = unknown, E = unknown>(): Effect.Effec
     (self) => runtime(self)<R>()
   )
 
+const internalFiberIdId = -1
+const internalFiberId = FiberId.make(internalFiberIdId, 0)
+const isInternalInterruption = Cause.reduceWithContext(undefined, {
+  emptyCase: constFalse,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: (_, fiberId) => HashSet.has(FiberId.ids(fiberId), internalFiberIdId),
+  sequentialCase: (_, left, right) => left || right,
+  parallelCase: (_, left, right) => left || right
+})
+
 /**
  * Add a fiber to the FiberSet. When the fiber completes, it will be removed.
  *
@@ -157,6 +169,7 @@ export const unsafeAdd: {
     fiber: Fiber.RuntimeFiber<XA, XE>,
     options?: {
       readonly interruptAs?: FiberId.FiberId | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): (self: FiberSet<A, E>) => void
   <A, E, XE extends E, XA extends A>(
@@ -164,6 +177,7 @@ export const unsafeAdd: {
     fiber: Fiber.RuntimeFiber<XA, XE>,
     options?: {
       readonly interruptAs?: FiberId.FiberId | undefined
+      readonly propagateInterruption?: boolean | undefined
     } | undefined
   ): void
 } = dual((args) => isFiberSet(args[0]), <A, E, XE extends E, XA extends A>(
@@ -171,10 +185,11 @@ export const unsafeAdd: {
   fiber: Fiber.RuntimeFiber<XA, XE>,
   options?: {
     readonly interruptAs?: FiberId.FiberId | undefined
+    readonly propagateInterruption?: boolean | undefined
   } | undefined
 ): void => {
   if (self.state._tag === "Closed") {
-    fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+    fiber.unsafeInterruptAsFork(FiberId.combine(options?.interruptAs ?? FiberId.none, internalFiberId))
     return
   } else if (self.state.backing.has(fiber)) {
     return
@@ -186,7 +201,14 @@ export const unsafeAdd: {
       return
     }
     self.state.backing.delete(fiber)
-    if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
+    if (
+      Exit.isFailure(exit) &&
+      (
+        options?.propagateInterruption === true ?
+          !isInternalInterruption(exit.cause) :
+          !Cause.isInterruptedOnly(exit.cause)
+      )
+    ) {
       Deferred.unsafeDone(self.deferred, exit as any)
     }
   })
@@ -200,26 +222,31 @@ export const unsafeAdd: {
  */
 export const add: {
   <A, E, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XA, XE>
+    fiber: Fiber.RuntimeFiber<XA, XE>,
+    options?: {
+      readonly propagateInterruption?: boolean | undefined
+    } | undefined
   ): (self: FiberSet<A, E>) => Effect.Effect<void>
   <A, E, XE extends E, XA extends A>(
     self: FiberSet<A, E>,
-    fiber: Fiber.RuntimeFiber<XA, XE>
+    fiber: Fiber.RuntimeFiber<XA, XE>,
+    options?: {
+      readonly propagateInterruption?: boolean | undefined
+    } | undefined
   ): Effect.Effect<void>
-} = dual<
-  <A, E, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => (self: FiberSet<A, E>) => Effect.Effect<void>,
+} = dual(
+  (args) => isFiberSet(args[0]),
   <A, E, XE extends E, XA extends A>(
     self: FiberSet<A, E>,
-    fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => Effect.Effect<void>
->(
-  2,
-  (self, fiber) =>
+    fiber: Fiber.RuntimeFiber<XA, XE>,
+    options?: {
+      readonly propagateInterruption?: boolean | undefined
+    } | undefined
+  ): Effect.Effect<void> =>
     Effect.fiberIdWith((fiberId) =>
       Effect.sync(() =>
         unsafeAdd(self, fiber, {
+          ...options,
           interruptAs: fiberId
         })
       )
@@ -231,13 +258,13 @@ export const add: {
  * @categories combinators
  */
 export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
-  Effect.suspend(() => {
+  Effect.withFiberRuntime((clearFiber) => {
     if (self.state._tag === "Closed") {
       return Effect.void
     }
     return Effect.forEach(self.state.backing, (fiber) =>
       // will be removed by the observer
-      Fiber.interrupt(fiber))
+      Fiber.interruptAs(fiber, FiberId.combine(clearFiber.id(), internalFiberId)))
   })
 
 /**
@@ -248,16 +275,25 @@ export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
  * @categories combinators
  */
 export const run: {
-  <A, E>(self: FiberSet<A, E>): <R, XE extends E, XA extends A>(
+  <A, E>(
+    self: FiberSet<A, E>,
+    options?: {
+      readonly propagateInterruption?: boolean | undefined
+    } | undefined
+  ): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>
   ) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
   <A, E, R, XE extends E, XA extends A>(
     self: FiberSet<A, E>,
-    effect: Effect.Effect<XA, XE, R>
+    effect: Effect.Effect<XA, XE, R>,
+    options?: {
+      readonly propagateInterruption?: boolean | undefined
+    } | undefined
   ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
   const self = arguments[0] as FiberSet<any, any>
-  if (arguments.length === 1) {
+  if (!Effect.isEffect(arguments[1])) {
+    const options = arguments[1] as { readonly propagateInterruption?: boolean | undefined } | undefined
     return (effect: Effect.Effect<any, any, any>) =>
       Effect.suspend(() => {
         if (self.state._tag === "Closed") {
@@ -266,12 +302,13 @@ export const run: {
         return Effect.uninterruptibleMask((restore) =>
           Effect.tap(
             restore(Effect.forkDaemon(effect)),
-            (fiber) => add(self, fiber)
+            (fiber) => add(self, fiber, options)
           )
         )
       })
   }
-  const effect = arguments[1] as Effect.Effect<any, any, any>
+  const effect = arguments[1]
+  const options = arguments[2] as { readonly propagateInterruption?: boolean | undefined } | undefined
   return Effect.suspend(() => {
     if (self.state._tag === "Closed") {
       return Effect.interrupt
@@ -279,7 +316,7 @@ export const run: {
     return Effect.uninterruptibleMask((restore) =>
       Effect.tap(
         restore(Effect.forkDaemon(effect)),
-        (fiber) => add(self, fiber)
+        (fiber) => add(self, fiber, options)
       )
     )
   }) as any
@@ -316,7 +353,9 @@ export const runtime: <A, E>(
 ) => <R = never>() => Effect.Effect<
   <XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>,
-    options?: Runtime.RunForkOptions | undefined
+    options?:
+      | Runtime.RunForkOptions & { readonly propagateInterruption?: boolean | undefined }
+      | undefined
   ) => Fiber.RuntimeFiber<XA, XE>,
   never,
   R
@@ -327,7 +366,9 @@ export const runtime: <A, E>(
       const runFork = Runtime.runFork(runtime)
       return <XE extends E, XA extends A>(
         effect: Effect.Effect<XA, XE, R>,
-        options?: Runtime.RunForkOptions | undefined
+        options?:
+          | Runtime.RunForkOptions & { readonly propagateInterruption?: boolean | undefined }
+          | undefined
       ) => {
         const fiber = runFork(effect, options)
         unsafeAdd(self, fiber)

package/src/Micro.ts

@@ -19,7 +19,7 @@ import { StructuralPrototype } from "./internal/effectable.js"
 import { SingleShotGen } from "./internal/singleShotGen.js"
 import * as Option from "./Option.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
-import { isIterable, isTagged, type Predicate, type Refinement } from "./Predicate.js"
+import { hasProperty, isIterable, isTagged, type Predicate, type Refinement } from "./Predicate.js"
 import type { ReadonlyRecord } from "./Record.js"
 import type { Sink, SinkTypeId } from "./Sink.js"
 import type { Stream, StreamTypeId } from "./Stream.js"
@@ -171,6 +171,13 @@ export type MicroCauseTypeId = typeof MicroCauseTypeId
  */
 export type MicroCause<E> = MicroCause.Die | MicroCause.Fail<E> | MicroCause.Interrupt
 
+/**
+ * @since 3.6.6
+ * @experimental
+ * @category guards
+ */
+export const isMicroCause = (self: unknown): self is MicroCause<unknown> => hasProperty(self, MicroCauseTypeId)
+
 /**
  * @since 3.4.6
  * @experimental

package/src/Stream.ts

@@ -3472,6 +3472,42 @@ export const provideSomeLayer: {
   ): Stream<A, E | E2, RIn | Exclude<R, ROut>>
 } = internal.provideSomeLayer
 
+/**
+ * Returns a stream that mirrors the first upstream to emit an item.
+ * As soon as one of the upstream emits a first value, the other is interrupted.
+ * The resulting stream will forward all items from the "winning" source stream.
+ * Any upstream failures will cause the returned stream to fail.
+ *
+ * @example
+ * import { Stream, Schedule, Console, Effect } from "effect"
+ *
+ * const stream = Stream.fromSchedule(Schedule.spaced('2 millis')).pipe(
+ *   Stream.race(Stream.fromSchedule(Schedule.spaced('1 millis'))),
+ *   Stream.take(6),
+ *   Stream.tap(Console.log)
+ * )
+ *
+ * Effect.runPromise(Stream.runDrain(stream))
+ * // Output each millisecond from the first stream, the rest streams are interrupted
+ * // 0
+ * // 1
+ * // 2
+ * // 3
+ * // 4
+ * // 5
+ * @since 3.7.0
+ * @category racing
+ */
+export const race: {
+  <AR, ER, RR>(
+    right: Stream<AR, ER, RR>
+  ): <AL, EL, RL>(left: Stream<AL, EL, RL>) => Stream<AL | AR, EL | ER, RL | RR>
+  <AL, EL, RL, AR, ER, RR>(
+    left: Stream<AL, EL, RL>,
+    right: Stream<AR, ER, RR>
+  ): Stream<AL | AR, EL | ER, RL | RR>
+} = internal.race
+
 /**
  * Returns a stream that mirrors the first upstream to emit an item.
  * As soon as one of the upstream emits a first value, all the others are interrupted.

package/src/internal/config.ts

@@ -447,6 +447,16 @@ export const string = (name?: string): Config.Config<string> => {
   return name === undefined ? config : nested(config, name)
 }
 
+/** @internal */
+export const nonEmptyString = (name?: string): Config.Config<string> => {
+  const config = primitive(
+    "a non-empty text property",
+    Either.liftPredicate((text) => text.length > 0, () => configError.MissingData([], "Expected a non-empty string"))
+  )
+
+  return name === undefined ? config : nested(config, name)
+}
+
 /** @internal */
 export const all = <const Arg extends Iterable<Config.Config<any>> | Record<string, Config.Config<any>>>(
   arg: Arg