effect 2.4.19 → 3.0.1

package/src/FiberMap.ts

@@ -13,6 +13,7 @@ import * as FiberRef from "./FiberRef.js"
 import { dual } from "./Function.js"
 import * as Inspectable from "./Inspectable.js"
 import type { FiberRuntime } from "./internal/fiberRuntime.js"
+import * as Iterable from "./Iterable.js"
 import * as MutableHashMap from "./MutableHashMap.js"
 import * as Option from "./Option.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
@@ -39,8 +40,14 @@ export interface FiberMap<in out K, out A = unknown, out E = unknown>
   extends Pipeable, Inspectable.Inspectable, Iterable<[K, Fiber.RuntimeFiber<A, E>]>
 {
   readonly [TypeId]: TypeId
-  readonly backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<A, E>>
-  readonly deferred: Deferred.Deferred<never, unknown>
+  readonly deferred: Deferred.Deferred<void, unknown>
+  /** @internal */
+  state: {
+    readonly _tag: "Open"
+    readonly backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<A, E>>
+  } | {
+    readonly _tag: "Closed"
+  }
 }
 
 /**
@@ -52,7 +59,10 @@ export const isFiberMap = (u: unknown): u is FiberMap<unknown> => Predicate.hasP
 const Proto = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: FiberMap<unknown>) {
-    return this.backing[Symbol.iterator]()
+    if (this.state._tag === "Closed") {
+      return Iterable.empty()
+    }
+    return this.state.backing[Symbol.iterator]()
   },
   toString(this: FiberMap<unknown>) {
     return Inspectable.format(this.toJSON())
@@ -60,7 +70,7 @@ const Proto = {
   toJSON(this: FiberMap<unknown>) {
     return {
       _id: "FiberMap",
-      backing: this.backing.toJSON()
+      state: this.state
     }
   },
   [Inspectable.NodeInspectSymbol](this: FiberMap<unknown>) {
@@ -73,10 +83,10 @@ const Proto = {
 
 const unsafeMake = <K, A = unknown, E = unknown>(
   backing: MutableHashMap.MutableHashMap<K, Fiber.RuntimeFiber<A, E>>,
-  deferred: Deferred.Deferred<never, E>
+  deferred: Deferred.Deferred<void, E>
 ): FiberMap<K, A, E> => {
   const self = Object.create(Proto)
-  self.backing = backing
+  self.state = { _tag: "Open", backing }
   self.deferred = deferred
   return self
 }
@@ -108,12 +118,19 @@ const unsafeMake = <K, A = unknown, E = unknown>(
  */
 export const make = <K, A = unknown, E = unknown>(): Effect.Effect<FiberMap<K, A, E>, never, Scope.Scope> =>
   Effect.acquireRelease(
-    Effect.map(Deferred.make<never, E>(), (deferred) =>
+    Effect.map(Deferred.make<void, E>(), (deferred) =>
       unsafeMake<K, A, E>(
         MutableHashMap.empty(),
         deferred
       )),
-    clear
+    (map) =>
+      Effect.zipRight(
+        clear(map),
+        Effect.suspend(() => {
+          map.state = { _tag: "Closed" }
+          return Deferred.done(map.deferred, Exit.void)
+        })
+      )
   )
 
 /**
@@ -126,7 +143,11 @@ export const makeRuntime = <R, K, E = unknown, A = unknown>(): Effect.Effect<
   <XE extends E, XA extends A>(
     key: K,
     effect: Effect.Effect<XA, XE, R>,
-    options?: Runtime.RunForkOptions | undefined
+    options?:
+      | Runtime.RunForkOptions & {
+        readonly onlyIfMissing?: boolean | undefined
+      }
+      | undefined
   ) => Fiber.RuntimeFiber<XA, XE>,
   never,
   Scope.Scope | R
@@ -147,41 +168,54 @@ export const unsafeSet: {
   <K, A, E, XE extends E, XA extends A>(
     key: K,
     fiber: Fiber.RuntimeFiber<XA, XE>,
-    interruptAs?: FiberId.FiberId
+    options?: {
+      readonly interruptAs?: FiberId.FiberId | undefined
+      readonly onlyIfMissing?: boolean | undefined
+    } | undefined
   ): (self: FiberMap<K, A, E>) => void
   <K, A, E, XE extends E, XA extends A>(
     self: FiberMap<K, A, E>,
     key: K,
     fiber: Fiber.RuntimeFiber<XA, XE>,
-    interruptAs?: FiberId.FiberId
+    options?: {
+      readonly interruptAs?: FiberId.FiberId | undefined
+      readonly onlyIfMissing?: boolean | undefined
+    } | undefined
   ): void
-} = dual<
-  <K, A, E, XE extends E, XA extends A>(
-    key: K,
-    fiber: Fiber.RuntimeFiber<XA, XE>,
-    interruptAs?: FiberId.FiberId
-  ) => (self: FiberMap<K, A, E>) => void,
-  <K, A, E, XE extends E, XA extends A>(
-    self: FiberMap<K, A, E>,
-    key: K,
-    fiber: Fiber.RuntimeFiber<XA, XE>,
-    interruptAs?: FiberId.FiberId
-  ) => void
->((args) => isFiberMap(args[0]), (self, key, fiber, interruptAs) => {
-  const previous = MutableHashMap.get(self.backing, key)
+} = dual((args) => isFiberMap(args[0]), <K, A, E, XE extends E, XA extends A>(
+  self: FiberMap<K, A, E>,
+  key: K,
+  fiber: Fiber.RuntimeFiber<XA, XE>,
+  options?: {
+    readonly interruptAs?: FiberId.FiberId | undefined
+    readonly onlyIfMissing?: boolean | undefined
+  } | undefined
+): void => {
+  if (self.state._tag === "Closed") {
+    fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+    return
+  }
+
+  const previous = MutableHashMap.get(self.state.backing, key)
   if (previous._tag === "Some") {
-    if (previous.value === fiber) {
+    if (options?.onlyIfMissing === true) {
+      fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+      return
+    } else if (previous.value === fiber) {
       return
     }
-    previous.value.unsafeInterruptAsFork(interruptAs ?? FiberId.none)
+    previous.value.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
   }
 
   ;(fiber as FiberRuntime<unknown, unknown>).setFiberRef(FiberRef.unhandledErrorLogLevel, Option.none())
-  MutableHashMap.set(self.backing, key, fiber)
+  MutableHashMap.set(self.state.backing, key, fiber)
   fiber.addObserver((exit) => {
-    const current = MutableHashMap.get(self.backing, key)
+    if (self.state._tag === "Closed") {
+      return
+    }
+    const current = MutableHashMap.get(self.state.backing, key)
     if (Option.isSome(current) && fiber === current.value) {
-      MutableHashMap.remove(self.backing, key)
+      MutableHashMap.remove(self.state.backing, key)
     }
     if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
       Deferred.unsafeDone(self.deferred, exit as any)
@@ -199,26 +233,35 @@ export const unsafeSet: {
 export const set: {
   <K, A, E, XE extends E, XA extends A>(
     key: K,
-    fiber: Fiber.RuntimeFiber<XA, XE>
+    fiber: Fiber.RuntimeFiber<XA, XE>,
+    options?: {
+      readonly onlyIfMissing?: boolean | undefined
+    } | undefined
   ): (self: FiberMap<K, A, E>) => Effect.Effect<void>
   <K, A, E, XE extends E, XA extends A>(
     self: FiberMap<K, A, E>,
     key: K,
-    fiber: Fiber.RuntimeFiber<XA, XE>
+    fiber: Fiber.RuntimeFiber<XA, XE>,
+    options?: {
+      readonly onlyIfMissing?: boolean | undefined
+    } | undefined
   ): Effect.Effect<void>
-} = dual<
-  <K, A, E, XE extends E, XA extends A>(
-    key: K,
-    fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => (self: FiberMap<K, A, E>) => Effect.Effect<void>,
-  <K, A, E, XE extends E, XA extends A>(
-    self: FiberMap<K, A, E>,
-    key: K,
-    fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => Effect.Effect<void>
->(3, (self, key, fiber) =>
+} = dual((args) => isFiberMap(args[0]), <K, A, E, XE extends E, XA extends A>(
+  self: FiberMap<K, A, E>,
+  key: K,
+  fiber: Fiber.RuntimeFiber<XA, XE>,
+  options?: {
+    readonly onlyIfMissing?: boolean | undefined
+  } | undefined
+): Effect.Effect<void> =>
   Effect.fiberIdWith(
-    (fiberId) => Effect.sync(() => unsafeSet(self, key, fiber, fiberId))
+    (fiberId) =>
+      Effect.sync(() =>
+        unsafeSet(self, key, fiber, {
+          interruptAs: fiberId,
+          onlyIfMissing: options?.onlyIfMissing
+        })
+      )
   ))
 
 /**
@@ -238,7 +281,7 @@ export const unsafeGet: {
     self: FiberMap<K, A, E>,
     key: K
   ) => Option.Option<Fiber.RuntimeFiber<A, E>>
->(2, (self, key) => MutableHashMap.get(self.backing, key))
+>(2, (self, key) => self.state._tag === "Closed" ? Option.none() : MutableHashMap.get(self.state.backing, key))
 
 /**
  * Retrieve a fiber from the FiberMap.
@@ -257,7 +300,36 @@ export const get: {
     self: FiberMap<K, A, E>,
     key: K
   ) => Effect.Effect<Fiber.RuntimeFiber<A, E>, NoSuchElementException>
->(2, (self, key) => Effect.suspend(() => MutableHashMap.get(self.backing, key)))
+>(2, (self, key) => Effect.suspend(() => unsafeGet(self, key)))
+
+/**
+ * Check if a key exists in the FiberMap.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+export const unsafeHas: {
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => boolean
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): boolean
+} = dual(
+  2,
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): boolean =>
+    self.state._tag === "Closed" ? false : MutableHashMap.has(self.state.backing, key)
+)
+
+/**
+ * Check if a key exists in the FiberMap.
+ *
+ * @since 2.0.0
+ * @categories combinators
+ */
+export const has: {
+  <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<boolean>
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<boolean>
+} = dual(
+  2,
+  <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<boolean> => Effect.sync(() => unsafeHas(self, key))
+)
 
 /**
  * Remove a fiber from the FiberMap, interrupting it if it exists.
@@ -278,11 +350,14 @@ export const remove: {
   ) => Effect.Effect<void>
 >(2, (self, key) =>
   Effect.suspend(() => {
-    const fiber = MutableHashMap.get(self.backing, key)
+    if (self.state._tag === "Closed") {
+      return Effect.void
+    }
+    const fiber = MutableHashMap.get(self.state.backing, key)
     if (fiber._tag === "None") {
-      return Effect.unit
+      return Effect.void
     }
-    MutableHashMap.remove(self.backing, key)
+    // will be removed by the observer
     return Fiber.interrupt(fiber.value)
   }))
 
@@ -291,12 +366,25 @@ export const remove: {
  * @categories combinators
  */
 export const clear = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<void> =>
-  Effect.zipRight(
-    Effect.forEach(self.backing, ([_, fiber]) => Fiber.interrupt(fiber)),
-    Effect.sync(() => {
-      MutableHashMap.clear(self.backing)
-    })
-  )
+  Effect.suspend(() => {
+    if (self.state._tag === "Closed") {
+      return Effect.void
+    }
+
+    return Effect.forEach(self.state.backing, ([, fiber]) =>
+      // will be removed by the observer
+      Fiber.interrupt(fiber))
+  })
+
+const constInterruptedFiber = (function() {
+  let fiber: Fiber.RuntimeFiber<never, never> | undefined = undefined
+  return () => {
+    if (fiber === undefined) {
+      fiber = Effect.runFork(Effect.interrupt)
+    }
+    return fiber
+  }
+})()
 
 /**
  * Run an Effect and add the forked fiber to the FiberMap.
@@ -308,32 +396,58 @@ export const clear = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<void> =>
 export const run: {
   <K, A, E>(
     self: FiberMap<K, A, E>,
-    key: K
+    key: K,
+    options?: {
+      readonly onlyIfMissing?: boolean | undefined
+    } | undefined
   ): <R, XE extends E, XA extends A>(
     effect: Effect.Effect<XA, XE, R>
   ) => Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
   <K, A, E, R, XE extends E, XA extends A>(
     self: FiberMap<K, A, E>,
     key: K,
-    effect: Effect.Effect<XA, XE, R>
+    effect: Effect.Effect<XA, XE, R>,
+    options?: {
+      readonly onlyIfMissing?: boolean | undefined
+    } | undefined
   ): Effect.Effect<Fiber.RuntimeFiber<XA, XE>, never, R>
 } = function() {
-  if (arguments.length === 2) {
+  if (Effect.isEffect(arguments[2])) {
     const self = arguments[0] as FiberMap<any>
     const key = arguments[1]
-    return (effect: Effect.Effect<any, any, any>) =>
-      Effect.tap(
-        Effect.forkDaemon(effect),
-        (fiber) => set(self, key, fiber)
+    const effect = arguments[2] as Effect.Effect<any, any, any>
+    const options = arguments[3] as { readonly onlyIfMissing?: boolean } | undefined
+    return Effect.suspend(() => {
+      if (self.state._tag === "Closed") {
+        return Effect.interrupt
+      } else if (options?.onlyIfMissing === true && unsafeHas(self, key)) {
+        return Effect.sync(constInterruptedFiber)
+      }
+      return Effect.uninterruptibleMask((restore) =>
+        Effect.tap(
+          restore(Effect.forkDaemon(effect)),
+          (fiber) => set(self, key, fiber, options)
+        )
       )
+    }) as any
   }
   const self = arguments[0] as FiberMap<any>
   const key = arguments[1]
-  const effect = arguments[2] as Effect.Effect<any, any, any>
-  return Effect.tap(
-    Effect.forkDaemon(effect),
-    (fiber) => set(self, key, fiber)
-  ) as any
+  const options = arguments[2] as { readonly onlyIfMissing?: boolean } | undefined
+  return (effect: Effect.Effect<any, any, any>) =>
+    Effect.suspend(() => {
+      if (self.state._tag === "Closed") {
+        return Effect.interrupt
+      } else if (options?.onlyIfMissing === true && unsafeHas(self, key)) {
+        return Effect.sync(constInterruptedFiber)
+      }
+      return Effect.uninterruptibleMask((restore) =>
+        Effect.tap(
+          restore(Effect.forkDaemon(effect)),
+          (fiber) => set(self, key, fiber, options)
+        )
+      )
+    })
 }
 
 /**
@@ -369,7 +483,11 @@ export const runtime: <K, A, E>(
   <XE extends E, XA extends A>(
     key: K,
     effect: Effect.Effect<XA, XE, R>,
-    options?: Runtime.RunForkOptions | undefined
+    options?:
+      | Runtime.RunForkOptions & {
+        readonly onlyIfMissing?: boolean | undefined
+      }
+      | undefined
   ) => Fiber.RuntimeFiber<XA, XE>,
   never,
   R
@@ -381,10 +499,19 @@ export const runtime: <K, A, E>(
       return <XE extends E, XA extends A>(
         key: K,
         effect: Effect.Effect<XA, XE, R>,
-        options?: Runtime.RunForkOptions | undefined
+        options?:
+          | Runtime.RunForkOptions & {
+            readonly onlyIfMissing?: boolean | undefined
+          }
+          | undefined
       ) => {
+        if (self.state._tag === "Closed") {
+          return constInterruptedFiber()
+        } else if (options?.onlyIfMissing === true && unsafeHas(self, key)) {
+          return constInterruptedFiber()
+        }
         const fiber = runFork(effect, options)
-        unsafeSet(self, key, fiber)
+        unsafeSet(self, key, fiber, options)
         return fiber
       }
     }
@@ -395,7 +522,7 @@ export const runtime: <K, A, E>(
  * @categories combinators
  */
 export const size = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<number> =>
-  Effect.sync(() => MutableHashMap.size(self.backing))
+  Effect.sync(() => self.state._tag === "Closed" ? 0 : MutableHashMap.size(self.state.backing))
 
 /**
  * Join all fibers in the FiberMap. If any of the Fiber's in the map terminate with a failure,
@@ -414,5 +541,5 @@ export const size = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<number> =>
  *   yield* _(FiberMap.join(map));
  * });
  */
-export const join = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<never, E> =>
-  Deferred.await(self.deferred as Deferred.Deferred<never, E>)
+export const join = <K, A, E>(self: FiberMap<K, A, E>): Effect.Effect<void, E> =>
+  Deferred.await(self.deferred as Deferred.Deferred<void, E>)

package/src/FiberRefs.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import type * as Arr from "./Array.js"
 import type * as Effect from "./Effect.js"
 import type * as FiberId from "./FiberId.js"
 import type * as FiberRef from "./FiberRef.js"
@@ -8,7 +9,6 @@ import type * as HashSet from "./HashSet.js"
 import * as internal from "./internal/fiberRefs.js"
 import type * as Option from "./Option.js"
 import type { Pipeable } from "./Pipeable.js"
-import type * as Arr from "./ReadonlyArray.js"
 
 /**
  * @since 2.0.0

package/src/FiberSet.ts

@@ -2,6 +2,7 @@
  * @since 2.0.0
  */
 import * as Effect from "effect/Effect"
+import * as FiberId from "effect/FiberId"
 import type * as Scope from "effect/Scope"
 import * as Cause from "./Cause.js"
 import * as Deferred from "./Deferred.js"
@@ -11,6 +12,7 @@ import * as FiberRef from "./FiberRef.js"
 import { dual } from "./Function.js"
 import * as Inspectable from "./Inspectable.js"
 import type { FiberRuntime } from "./internal/fiberRuntime.js"
+import * as Iterable from "./Iterable.js"
 import * as Option from "./Option.js"
 import { type Pipeable, pipeArguments } from "./Pipeable.js"
 import * as Predicate from "./Predicate.js"
@@ -36,8 +38,14 @@ export interface FiberSet<out A = unknown, out E = unknown>
   extends Pipeable, Inspectable.Inspectable, Iterable<Fiber.RuntimeFiber<A, E>>
 {
   readonly [TypeId]: TypeId
-  readonly backing: Set<Fiber.RuntimeFiber<A, E>>
-  readonly deferred: Deferred.Deferred<never, unknown>
+  readonly deferred: Deferred.Deferred<void, unknown>
+  /** @internal */
+  state: {
+    readonly _tag: "Open"
+    readonly backing: Set<Fiber.RuntimeFiber<A, E>>
+  } | {
+    readonly _tag: "Closed"
+  }
 }
 
 /**
@@ -49,7 +57,10 @@ export const isFiberSet = (u: unknown): u is FiberSet<unknown, unknown> => Predi
 const Proto = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: FiberSet<unknown, unknown>) {
-    return this.backing[Symbol.iterator]()
+    if (this.state._tag === "Closed") {
+      return Iterable.empty()
+    }
+    return this.state.backing[Symbol.iterator]()
   },
   toString(this: FiberSet<unknown, unknown>) {
     return Inspectable.format(this.toJSON())
@@ -57,7 +68,7 @@ const Proto = {
   toJSON(this: FiberSet<unknown, unknown>) {
     return {
       _id: "FiberMap",
-      backing: Inspectable.toJSON(Array.from(this.backing))
+      state: this.state
     }
   },
   [Inspectable.NodeInspectSymbol](this: FiberSet<unknown, unknown>) {
@@ -70,10 +81,10 @@ const Proto = {
 
 const unsafeMake = <A, E>(
   backing: Set<Fiber.RuntimeFiber<A, E>>,
-  deferred: Deferred.Deferred<never, unknown>
+  deferred: Deferred.Deferred<void, unknown>
 ): FiberSet<A, E> => {
   const self = Object.create(Proto)
-  self.backing = backing
+  self.state = { _tag: "Open", backing }
   self.deferred = deferred
   return self
 }
@@ -105,8 +116,15 @@ const unsafeMake = <A, E>(
  */
 export const make = <A = unknown, E = unknown>(): Effect.Effect<FiberSet<A, E>, never, Scope.Scope> =>
   Effect.acquireRelease(
-    Effect.map(Deferred.make<never, unknown>(), (deferred) => unsafeMake(new Set(), deferred)),
-    clear
+    Effect.map(Deferred.make<void, unknown>(), (deferred) => unsafeMake(new Set(), deferred)),
+    (set) =>
+      Effect.zipRight(
+        clear(set),
+        Effect.suspend(() => {
+          set.state = { _tag: "Closed" }
+          return Deferred.done(set.deferred, Exit.void)
+        })
+      )
   )
 
 /**
@@ -135,24 +153,39 @@ export const makeRuntime = <R = never, A = unknown, E = unknown>(): Effect.Effec
  * @categories combinators
  */
 export const unsafeAdd: {
-  <A, E, XE extends E, XA extends A>(fiber: Fiber.RuntimeFiber<XA, XE>): (self: FiberSet<A, E>) => void
-  <A, E, XE extends E, XA extends A>(self: FiberSet<A, E>, fiber: Fiber.RuntimeFiber<XA, XE>): void
-} = dual<
   <A, E, XE extends E, XA extends A>(
-    fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => (self: FiberSet<A, E>) => void,
+    fiber: Fiber.RuntimeFiber<XA, XE>,
+    options?: {
+      readonly interruptAs?: FiberId.FiberId | undefined
+    } | undefined
+  ): (self: FiberSet<A, E>) => void
   <A, E, XE extends E, XA extends A>(
     self: FiberSet<A, E>,
-    fiber: Fiber.RuntimeFiber<XA, XE>
-  ) => void
->(2, (self, fiber) => {
-  if (self.backing.has(fiber)) {
+    fiber: Fiber.RuntimeFiber<XA, XE>,
+    options?: {
+      readonly interruptAs?: FiberId.FiberId | undefined
+    } | undefined
+  ): void
+} = dual((args) => isFiberSet(args[0]), <A, E, XE extends E, XA extends A>(
+  self: FiberSet<A, E>,
+  fiber: Fiber.RuntimeFiber<XA, XE>,
+  options?: {
+    readonly interruptAs?: FiberId.FiberId | undefined
+  } | undefined
+): void => {
+  if (self.state._tag === "Closed") {
+    fiber.unsafeInterruptAsFork(options?.interruptAs ?? FiberId.none)
+    return
+  } else if (self.state.backing.has(fiber)) {
     return
   }
   ;(fiber as FiberRuntime<unknown, unknown>).setFiberRef(FiberRef.unhandledErrorLogLevel, Option.none())
-  self.backing.add(fiber)
+  self.state.backing.add(fiber)
   fiber.addObserver((exit) => {
-    self.backing.delete(fiber)
+    if (self.state._tag === "Closed") {
+      return
+    }
+    self.state.backing.delete(fiber)
     if (Exit.isFailure(exit) && !Cause.isInterruptedOnly(exit.cause)) {
       Deferred.unsafeDone(self.deferred, exit as any)
     }
@@ -181,19 +214,31 @@ export const add: {
     self: FiberSet<A, E>,
     fiber: Fiber.RuntimeFiber<XA, XE>
   ) => Effect.Effect<void>
->(2, (self, fiber) => Effect.sync(() => unsafeAdd(self, fiber)))
+>(
+  2,
+  (self, fiber) =>
+    Effect.fiberIdWith((fiberId) =>
+      Effect.sync(() =>
+        unsafeAdd(self, fiber, {
+          interruptAs: fiberId
+        })
+      )
+    )
+)
 
 /**
  * @since 2.0.0
  * @categories combinators
  */
 export const clear = <A, E>(self: FiberSet<A, E>): Effect.Effect<void> =>
-  Effect.zipRight(
-    Effect.forEach(self.backing, (fiber) => Fiber.interrupt(fiber)),
-    Effect.sync(() => {
-      self.backing.clear()
-    })
-  )
+  Effect.suspend(() => {
+    if (self.state._tag === "Closed") {
+      return Effect.void
+    }
+    return Effect.forEach(self.state.backing, (fiber) =>
+      // will be removed by the observer
+      Fiber.interrupt(fiber))
+  })
 
 /**
  * Fork an Effect and add the forked fiber to the FiberSet.
@@ -214,16 +259,30 @@ export const run: {
   const self = arguments[0] as FiberSet<any, any>
   if (arguments.length === 1) {
     return (effect: Effect.Effect<any, any, any>) =>
+      Effect.suspend(() => {
+        if (self.state._tag === "Closed") {
+          return Effect.interrupt
+        }
+        return Effect.uninterruptibleMask((restore) =>
+          Effect.tap(
+            restore(Effect.forkDaemon(effect)),
+            (fiber) => add(self, fiber)
+          )
+        )
+      })
+  }
+  const effect = arguments[1] as Effect.Effect<any, any, any>
+  return Effect.suspend(() => {
+    if (self.state._tag === "Closed") {
+      return Effect.interrupt
+    }
+    return Effect.uninterruptibleMask((restore) =>
       Effect.tap(
-        Effect.forkDaemon(effect),
+        restore(Effect.forkDaemon(effect)),
         (fiber) => add(self, fiber)
       )
-  }
-  const effect = arguments[1] as Effect.Effect<any, any, any>
-  return Effect.tap(
-    Effect.forkDaemon(effect),
-    (fiber) => add(self, fiber)
-  ) as any
+    )
+  }) as any
 }
 
 /**
@@ -281,7 +340,8 @@ export const runtime: <A, E>(
  * @since 2.0.0
  * @categories combinators
  */
-export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> => Effect.sync(() => self.backing.size)
+export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> =>
+  Effect.sync(() => self.state._tag === "Closed" ? 0 : self.state.backing.size)
 
 /**
  * Join all fibers in the FiberSet. If any of the Fiber's in the set terminate with a failure,
@@ -300,5 +360,5 @@ export const size = <A, E>(self: FiberSet<A, E>): Effect.Effect<number> => Effec
  *   yield* _(FiberSet.join(set));
  * });
  */
-export const join = <A, E>(self: FiberSet<A, E>): Effect.Effect<never, E> =>
-  Deferred.await(self.deferred as Deferred.Deferred<never, E>)
+export const join = <A, E>(self: FiberSet<A, E>): Effect.Effect<void, E> =>
+  Deferred.await(self.deferred as Deferred.Deferred<void, E>)