effect 4.0.0-beta.70 → 4.0.0-beta.72

package/dist/Fiber.js

@@ -7,6 +7,21 @@ export {
 /**
  * Waits for a fiber to complete and returns its exit value.
  *
+ * **When to use**
+ *
+ * Use when you need to inspect whether the fiber succeeded,
+ * failed, died, or was interrupted without propagating the failure.
+ *
+ * **Details**
+ *
+ * The returned Effect always succeeds with an `Exit` describing the fiber's
+ * outcome.
+ *
+ * **Gotchas**
+ *
+ * This does not flatten the fiber result into the current Effect. Use
+ * {@link join} when you want fiber failures to fail the current Effect.
+ *
  * **Example** (Awaiting a fiber exit)
  *
  * ```ts
@@ -27,6 +42,20 @@ await_ as await };
  * Waits for all fibers in the provided iterable to complete and returns
  * an array of their exit values.
  *
+ * **When to use**
+ *
+ * Use when you need every fiber outcome as data, including failures and
+ * interruptions.
+ *
+ * **Details**
+ *
+ * The returned array is ordered like the input iterable.
+ *
+ * **Gotchas**
+ *
+ * Failures are captured as `Exit.Failure` values. Use {@link joinAll} when you
+ * want the first failed fiber to fail the returned Effect.
+ *
  * **Example** (Awaiting multiple fiber exits)
  *
  * ```ts
@@ -48,6 +77,16 @@ export const awaitAll = effect.fiberAwaitAll;
  * Joins a fiber, blocking until it completes. If the fiber succeeds,
  * returns its value. If it fails, the error is propagated.
  *
+ * **When to use**
+ *
+ * Use when the forked fiber is part of the current workflow and
+ * its failure should fail the current Effect.
+ *
+ * **Gotchas**
+ *
+ * Joining a failed fiber propagates the fiber's Cause. Use {@link await_ await} when
+ * you need to inspect the `Exit` instead of failing.
+ *
  * **Example** (Joining a fiber)
  *
  * ```ts
@@ -60,6 +99,8 @@ export const awaitAll = effect.fiberAwaitAll;
  * })
  * ```
  *
+ * @see {@link await_ await} for inspecting the fiber outcome as an Exit
+ *
  * @category combinators
  * @since 2.0.0
  */
@@ -67,12 +108,24 @@ export const join = effect.fiberJoin;
 /**
  * Waits for all fibers to succeed and returns their values in input order.
  *
+ * **When to use**
+ *
+ * Use when every fiber must succeed and you want the successful values rather
+ * than the `Exit` values.
+ *
  * **Details**
  *
  * If any fiber fails, the returned `Effect` fails with that fiber's cause and
  * stops waiting for additional results. This does not interrupt the remaining
  * fibers.
  *
+ * **Gotchas**
+ *
+ * A failure stops waiting, but it does not interrupt any other fibers. Use
+ * {@link interruptAll} separately when remaining fibers should be stopped.
+ *
+ * @see {@link awaitAll} for collecting every fiber outcome as an Exit
+ *
  * @category combinators
  * @since 2.0.0
  */
@@ -81,6 +134,19 @@ export const joinAll = effect.fiberJoinAll;
  * Interrupts a fiber, causing it to stop executing and clean up any
  * acquired resources.
  *
+ * **When to use**
+ *
+ * Use when a forked fiber is no longer needed and should be cancelled.
+ *
+ * **Details**
+ *
+ * The returned Effect completes only after the interrupted fiber has completed.
+ *
+ * **Gotchas**
+ *
+ * Interruption is cooperative. A fiber can continue running while it is inside
+ * uninterruptible work or finalizers.
+ *
  * **Example** (Interrupting a fiber)
  *
  * ```ts
@@ -95,6 +161,9 @@ export const joinAll = effect.fiberJoinAll;
  * })
  * ```
  *
+ * @see {@link interruptAs} for specifying the interrupting fiber ID
+ * @see {@link await_ await} for observing the interrupted fiber's Exit
+ *
  * @category interruption
  * @since 2.0.0
  */
@@ -103,6 +172,20 @@ export const interrupt = effect.fiberInterrupt;
  * Interrupts a fiber with a specific fiber ID as the interruptor. This allows
  * tracking which fiber initiated the interruption.
  *
+ * **When to use**
+ *
+ * Use when runtime diagnostics or tracing should attribute the interruption to
+ * a specific fiber ID.
+ *
+ * **Details**
+ *
+ * The returned Effect completes only after the interrupted fiber has completed.
+ *
+ * **Gotchas**
+ *
+ * The supplied ID affects the recorded interruptor. It does not make
+ * interruption synchronous or force uninterruptible regions to stop early.
+ *
  * **Example** (Interrupting a fiber as another fiber)
  *
  * ```ts
@@ -119,6 +202,8 @@ export const interrupt = effect.fiberInterrupt;
  * })
  * ```
  *
+ * @see {@link interrupt} for using the current fiber as the interruptor
+ *
  * @category interruption
  * @since 2.0.0
  */
@@ -127,6 +212,20 @@ export const interruptAs = effect.fiberInterruptAs;
  * Interrupts all fibers in the provided iterable, causing them to stop executing
  * and clean up any acquired resources.
  *
+ * **When to use**
+ *
+ * Use when a group of forked fibers is no longer needed.
+ *
+ * **Details**
+ *
+ * The current fiber is recorded as the interruptor. The returned Effect
+ * completes only after all interrupted fibers have completed.
+ *
+ * **Gotchas**
+ *
+ * Interruption is cooperative for each fiber. The returned Effect can wait for
+ * uninterruptible work and finalizers in any interrupted fiber.
+ *
  * **Example** (Interrupting multiple fibers)
  *
  * ```ts
@@ -166,6 +265,8 @@ export const interruptAs = effect.fiberInterruptAs;
  * })
  * ```
  *
+ * @see {@link interruptAllAs} for specifying the interrupting fiber ID
+ *
  * @category interruption
  * @since 2.0.0
  */
@@ -175,6 +276,21 @@ export const interruptAll = effect.fiberInterruptAll;
  * interrupting fiber. This allows you to control which fiber is considered the source
  * of the interruption, which can be useful for debugging and tracing.
  *
+ * **When to use**
+ *
+ * Use to interrupt several fibers while recording a specific fiber ID as the
+ * interruptor.
+ *
+ * **Details**
+ *
+ * The returned Effect completes only after all interrupted fibers have
+ * completed.
+ *
+ * **Gotchas**
+ *
+ * The supplied ID affects the recorded interruptor. It does not make
+ * interruption synchronous or force uninterruptible regions to stop early.
+ *
  * **Example** (Interrupting multiple fibers as another fiber)
  *
  * ```ts
@@ -209,14 +325,26 @@ export const interruptAll = effect.fiberInterruptAll;
  * })
  * ```
  *
+ * @see {@link interruptAll} for using the current fiber as the interruptor
+ *
  * @category interruption
  * @since 2.0.0
  */
 export const interruptAllAs = effect.fiberInterruptAllAs;
 /**
- * Tests if a value is a Fiber. This is a type guard that can be used to
+ * Checks whether a value is a Fiber. This is a type guard that can be used to
  * determine if an unknown value is a Fiber instance.
  *
+ * **When to use**
+ *
+ * Use when checking values at boundaries where an unknown value may be a
+ * runtime fiber.
+ *
+ * **Details**
+ *
+ * The check looks for the internal Fiber type ID marker and does not inspect
+ * the fiber's current state.
+ *
  * **Example** (Checking for fibers)
  *
  * ```ts
@@ -249,6 +377,16 @@ export const isFiber = u => hasProperty(u, effect.FiberTypeId);
  * Returns the current fiber if called from within a fiber context,
  * otherwise returns `undefined`.
  *
+ * **When to use**
+ *
+ * Use when you need low-level runtime integrations that need access to the currently
+ * executing fiber.
+ *
+ * **Gotchas**
+ *
+ * This is a synchronous accessor, not an Effect. It returns `undefined` outside
+ * an active fiber runtime context.
+ *
  * **Example** (Getting the current fiber)
  *
  * ```ts
@@ -267,14 +405,25 @@ export const isFiber = u => hasProperty(u, effect.FiberTypeId);
  */
 export const getCurrent = effect.getCurrentFiber;
 /**
- * Links a fiber to a `Scope` and returns the same fiber.
+ * Adds a fiber to a `Scope` and returns the same fiber.
+ *
+ * **When to use**
+ *
+ * Use when a manually managed fiber should be interrupted when a Scope closes.
  *
  * **Details**
  *
  * When the scope is closed, the fiber is interrupted. If the scope is already
  * closed, the fiber is interrupted immediately.
  *
- * @category Scope
+ * **Gotchas**
+ *
+ * This does not wait for the fiber to complete. It only registers the
+ * interruption finalizer and returns the same fiber.
+ *
+ * @see {@link interrupt} for interrupting and waiting for completion
+ *
+ * @category resource management
  * @since 4.0.0
  */
 export const runIn = effect.fiberRunIn;

package/dist/Fiber.js.map

@@ -1 +1 @@
-{"version":3,"file":"Fiber.js","names":["effect","version","hasProperty","TypeId","await_","fiberAwait","await","awaitAll","fiberAwaitAll","join","fiberJoin","joinAll","fiberJoinAll","interrupt","fiberInterrupt","interruptAs","fiberInterruptAs","interruptAll","fiberInterruptAll","interruptAllAs","fiberInterruptAllAs","isFiber","u","FiberTypeId","getCurrent","getCurrentFiber","runIn","fiberRunIn"],"sources":["../src/Fiber.ts"],"sourcesContent":[null],"mappings":"AA+EA,OAAO,KAAKA,MAAM,MAAM,sBAAsB;AAC9C,SAASC,OAAO,QAAQ,uBAAuB;AAG/C,SAASC,WAAW,QAAQ,gBAAgB;AAO5C,MAAMC,MAAM,GAAG,iBAAiBF,OAAO,EAAE;AAuGzC,MAAMG,MAAM,GAAoDJ,MAAM,CAACK,UAAU;AACjF;AACE;;;;;;;;;;;;;;;;;;AAkBAD,MAAM,IAAIE,KAAK;AAEjB;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAMC,QAAQ,GASjBP,MAAM,CAACQ,aAAa;AAExB;;;;;;;;;;;;;;;;;;;AAmBA,OAAO,MAAMC,IAAI,GAA8CT,MAAM,CAACU,SAAS;AAE/E;;;;;;;;;;;;AAYA,OAAO,MAAMC,OAAO,GAQhBX,MAAM,CAACY,YAAY;AAEvB;;;;;;;;;;;;;;;;;;;;;AAqBA,OAAO,MAAMC,SAAS,GAA8Cb,MAAM,CAACc,cAAc;AAEzF;;;;;;;;;;;;;;;;;;;;;;;AAuBA,OAAO,MAAMC,WAAW,GAwDpBf,MAAM,CAACgB,gBAAgB;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8CA,OAAO,MAAMC,YAAY,GAELjB,MAAM,CAACkB,iBAAiB;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,OAAO,MAAMC,cAAc,GAuFvBnB,MAAM,CAACoB,mBAAmB;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAMC,OAAO,GAClBC,CAAU,IACuBpB,WAAW,CAACoB,CAAC,EAAEtB,MAAM,CAACuB,WAAW,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;AAoBA,OAAO,MAAMC,UAAU,GAAsCxB,MAAM,CAACyB,eAAe;AAEnF;;;;;;;;;;;AAWA,OAAO,MAAMC,KAAK,GAyBd1B,MAAM,CAAC2B,UAAU","ignoreList":[]}
+{"version":3,"file":"Fiber.js","names":["effect","version","hasProperty","TypeId","await_","fiberAwait","await","awaitAll","fiberAwaitAll","join","fiberJoin","joinAll","fiberJoinAll","interrupt","fiberInterrupt","interruptAs","fiberInterruptAs","interruptAll","fiberInterruptAll","interruptAllAs","fiberInterruptAllAs","isFiber","u","FiberTypeId","getCurrent","getCurrentFiber","runIn","fiberRunIn"],"sources":["../src/Fiber.ts"],"sourcesContent":[null],"mappings":"AA4DA,OAAO,KAAKA,MAAM,MAAM,sBAAsB;AAC9C,SAASC,OAAO,QAAQ,uBAAuB;AAG/C,SAASC,WAAW,QAAQ,gBAAgB;AAO5C,MAAMC,MAAM,GAAG,iBAAiBF,OAAO,EAAE;AAsIzC,MAAMG,MAAM,GAAoDJ,MAAM,CAACK,UAAU;AACjF;AACE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCAD,MAAM,IAAIE,KAAK;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkCA,OAAO,MAAMC,QAAQ,GASjBP,MAAM,CAACQ,aAAa;AAExB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,OAAO,MAAMC,IAAI,GAA8CT,MAAM,CAACU,SAAS;AAE/E;;;;;;;;;;;;;;;;;;;;;;;;AAwBA,OAAO,MAAMC,OAAO,GAQhBX,MAAM,CAACY,YAAY;AAEvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,OAAO,MAAMC,SAAS,GAA8Cb,MAAM,CAACc,cAAc;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuCA,OAAO,MAAMC,WAAW,GAwFpBf,MAAM,CAACgB,gBAAgB;AAE3B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8DA,OAAO,MAAMC,YAAY,GAELjB,MAAM,CAACkB,iBAAiB;AAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,OAAO,MAAMC,cAAc,GAyHvBnB,MAAM,CAACoB,mBAAmB;AAE9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCA,OAAO,MAAMC,OAAO,GAClBC,CAAU,IACuBpB,WAAW,CAACoB,CAAC,EAAEtB,MAAM,CAACuB,WAAW,CAAC;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,OAAO,MAAMC,UAAU,GAAsCxB,MAAM,CAACyB,eAAe;AAEnF;;;;;;;;;;;;;;;;;;;;;;AAsBA,OAAO,MAAMC,KAAK,GA+Cd1B,MAAM,CAAC2B,UAAU","ignoreList":[]}

package/dist/FiberHandle.d.ts

@@ -166,7 +166,7 @@ export declare const makeRuntimePromise: <R = never, A = unknown, E = unknown>()
     readonly propagateInterruption?: boolean | undefined;
 } | undefined) => Promise<XA>), never, Scope.Scope | R>;
 /**
- * Set the fiber in a FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
+ * Sets 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.
  *
  * **Example** (Setting a fiber unsafely)
@@ -192,7 +192,7 @@ export declare const makeRuntimePromise: <R = never, A = unknown, E = unknown>()
  */
 export declare const setUnsafe: {
     /**
-     * Set the fiber in a FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
+     * Sets 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.
      *
      * **Example** (Setting a fiber unsafely)
@@ -221,7 +221,7 @@ export declare const setUnsafe: {
         readonly propagateInterruption?: boolean | undefined;
     }): (self: FiberHandle<A, E>) => void;
     /**
-     * Set the fiber in a FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
+     * Sets 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.
      *
      * **Example** (Setting a fiber unsafely)
@@ -351,7 +351,7 @@ export declare const set: {
     }): Effect.Effect<void>;
 };
 /**
- * Retrieve the fiber from the FiberHandle.
+ * Retrieves the fiber from the FiberHandle synchronously.
  *
  * **Example** (Reading the current fiber unsafely)
  *
@@ -377,7 +377,7 @@ export declare const set: {
  */
 export declare function getUnsafe<A, E>(self: FiberHandle<A, E>): Option.Option<Fiber.Fiber<A, E>>;
 /**
- * Retrieve the fiber from the FiberHandle.
+ * Retrieves the fiber from the FiberHandle effectfully.
  *
  * **Example** (Reading the current fiber)
  *
@@ -647,7 +647,7 @@ export declare const runtimePromise: <A, E>(self: FiberHandle<A, E>) => <R = nev
  */
 export declare const join: <A, E>(self: FiberHandle<A, E>) => Effect.Effect<void, E>;
 /**
- * Wait for the fiber in the FiberHandle to complete.
+ * Waits for the fiber in the FiberHandle to complete.
  *
  * **Example** (Waiting for a fiber to complete)
  *

package/dist/FiberHandle.js

@@ -194,7 +194,7 @@ export const makeRuntimePromise = () => Effect.flatMap(make(), self => runtimePr
 const internalFiberId = -1;
 const isInternalInterruption = /*#__PURE__*/Filter.toPredicate(/*#__PURE__*/Filter.compose(Cause.filterInterruptors, /*#__PURE__*/Filter.has(internalFiberId)));
 /**
- * Set the fiber in a FiberHandle. When the fiber completes, it will be removed from the FiberHandle.
+ * Sets 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.
  *
  * **Example** (Setting a fiber unsafely)
@@ -277,7 +277,7 @@ export const set = /*#__PURE__*/dual(args => isFiberHandle(args[0]), (self, fibe
   propagateInterruption: options?.propagateInterruption
 })));
 /**
- * Retrieve the fiber from the FiberHandle.
+ * Retrieves the fiber from the FiberHandle synchronously.
  *
  * **Example** (Reading the current fiber unsafely)
  *
@@ -305,7 +305,7 @@ export function getUnsafe(self) {
   return self.state._tag === "Closed" ? Option.none() : Option.fromUndefinedOr(self.state.fiber);
 }
 /**
- * Retrieve the fiber from the FiberHandle.
+ * Retrieves the fiber from the FiberHandle effectfully.
  *
  * **Example** (Reading the current fiber)
  *
@@ -545,7 +545,7 @@ export const runtimePromise = self => () => Effect.map(runtime(self)(), runFork
  */
 export const join = self => Deferred.await(self.deferred);
 /**
- * Wait for the fiber in the FiberHandle to complete.
+ * Waits for the fiber in the FiberHandle to complete.
  *
  * **Example** (Waiting for a fiber to complete)
  *

package/dist/FiberMap.d.ts

@@ -402,7 +402,7 @@ export declare const set: {
     } | undefined): Effect.Effect<void>;
 };
 /**
- * Retrieve a fiber from the FiberMap.
+ * Retrieves a fiber from the FiberMap synchronously.
  *
  * **Example** (Retrieving a fiber unsafely)
  *
@@ -433,7 +433,7 @@ export declare const set: {
  */
 export declare const getUnsafe: {
     /**
-     * Retrieve a fiber from the FiberMap.
+     * Retrieves a fiber from the FiberMap synchronously.
      *
      * **Example** (Retrieving a fiber unsafely)
      *
@@ -464,7 +464,7 @@ export declare const getUnsafe: {
      */
     <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Option.Option<Fiber.Fiber<A, E>>;
     /**
-     * Retrieve a fiber from the FiberMap.
+     * Retrieves a fiber from the FiberMap synchronously.
      *
      * **Example** (Retrieving a fiber unsafely)
      *
@@ -496,7 +496,7 @@ export declare const getUnsafe: {
     <K, A, E>(self: FiberMap<K, A, E>, key: K): Option.Option<Fiber.Fiber<A, E>>;
 };
 /**
- * Retrieve a fiber from the FiberMap.
+ * Retrieves a fiber from the FiberMap effectfully.
  *
  * **Details**
  *
@@ -531,7 +531,7 @@ export declare const getUnsafe: {
  */
 export declare const get: {
     /**
-     * Retrieve a fiber from the FiberMap.
+     * Retrieves a fiber from the FiberMap effectfully.
      *
      * **Details**
      *
@@ -566,7 +566,7 @@ export declare const get: {
      */
     <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>;
     /**
-     * Retrieve a fiber from the FiberMap.
+     * Retrieves a fiber from the FiberMap effectfully.
      *
      * **Details**
      *
@@ -602,7 +602,7 @@ export declare const get: {
     <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<Option.Option<Fiber.Fiber<A, E>>>;
 };
 /**
- * Check if a key exists in the FiberMap.
+ * Checks whether a key exists in the FiberMap.
  *
  * **Example** (Checking if a key exists unsafely)
  *
@@ -626,7 +626,7 @@ export declare const get: {
  */
 export declare const hasUnsafe: {
     /**
-     * Check if a key exists in the FiberMap.
+     * Checks whether a key exists in the FiberMap.
      *
      * **Example** (Checking if a key exists unsafely)
      *
@@ -650,7 +650,7 @@ export declare const hasUnsafe: {
      */
     <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => boolean;
     /**
-     * Check if a key exists in the FiberMap.
+     * Checks whether a key exists in the FiberMap.
      *
      * **Example** (Checking if a key exists unsafely)
      *
@@ -675,7 +675,7 @@ export declare const hasUnsafe: {
     <K, A, E>(self: FiberMap<K, A, E>, key: K): boolean;
 };
 /**
- * Check if a key exists in the FiberMap.
+ * Checks whether a key exists in the FiberMap.
  * This is the Effect-wrapped version of `hasUnsafe`.
  *
  * **Example** (Checking if a key exists)
@@ -703,7 +703,7 @@ export declare const hasUnsafe: {
  */
 export declare const has: {
     /**
-     * Check if a key exists in the FiberMap.
+     * Checks whether a key exists in the FiberMap.
      * This is the Effect-wrapped version of `hasUnsafe`.
      *
      * **Example** (Checking if a key exists)
@@ -731,7 +731,7 @@ export declare const has: {
      */
     <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<boolean>;
     /**
-     * Check if a key exists in the FiberMap.
+     * Checks whether a key exists in the FiberMap.
      * This is the Effect-wrapped version of `hasUnsafe`.
      *
      * **Example** (Checking if a key exists)
@@ -760,7 +760,7 @@ export declare const has: {
     <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<boolean>;
 };
 /**
- * Remove a fiber from the FiberMap, interrupting it if it exists.
+ * Removes a fiber from the FiberMap, interrupting it if it exists.
  *
  * **Example** (Removing a fiber)
  *
@@ -788,7 +788,7 @@ export declare const has: {
  */
 export declare const remove: {
     /**
-     * Remove a fiber from the FiberMap, interrupting it if it exists.
+     * Removes a fiber from the FiberMap, interrupting it if it exists.
      *
      * **Example** (Removing a fiber)
      *
@@ -816,7 +816,7 @@ export declare const remove: {
      */
     <K>(key: K): <A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void>;
     /**
-     * Remove a fiber from the FiberMap, interrupting it if it exists.
+     * Removes a fiber from the FiberMap, interrupting it if it exists.
      *
      * **Example** (Removing a fiber)
      *
@@ -845,7 +845,7 @@ export declare const remove: {
     <K, A, E>(self: FiberMap<K, A, E>, key: K): Effect.Effect<void>;
 };
 /**
- * Remove all fibers from the FiberMap, interrupting them.
+ * Removes all fibers from the FiberMap, interrupting them.
  *
  * **Example** (Clearing all fibers)
  *
@@ -1061,7 +1061,7 @@ export declare const runtimePromise: <K, A, E>(self: FiberMap<K, A, E>) => <R =
     readonly propagateInterruption?: boolean | undefined;
 }) | undefined) => Promise<XA>), never, R>;
 /**
- * Get the number of fibers currently in the FiberMap.
+ * Gets the number of fibers currently in the FiberMap.
  *
  * **Example** (Checking the map size)
  *
@@ -1114,7 +1114,7 @@ export declare const size: <K, A, E>(self: FiberMap<K, A, E>) => Effect.Effect<n
  */
 export declare const join: <K, A, E>(self: FiberMap<K, A, E>) => Effect.Effect<void, E>;
 /**
- * Wait for the FiberMap to be empty.
+ * Waits for the FiberMap to be empty.
  * This will wait for all currently running fibers to complete.
  *
  * **Example** (Waiting for an empty map)

package/dist/FiberMap.js

@@ -309,7 +309,7 @@ export const setUnsafe = /*#__PURE__*/dual(args => isFiberMap(args[0]), (self, k
  */
 export const set = /*#__PURE__*/dual(args => isFiberMap(args[0]), (self, key, fiber, options) => Effect.sync(() => setUnsafe(self, key, fiber, options)));
 /**
- * Retrieve a fiber from the FiberMap.
+ * Retrieves a fiber from the FiberMap synchronously.
  *
  * **Example** (Retrieving a fiber unsafely)
  *
@@ -342,7 +342,7 @@ export const getUnsafe = /*#__PURE__*/dual(2, (self, key) => {
   return self.state._tag === "Closed" ? Option.none() : MutableHashMap.get(self.state.backing, key);
 });
 /**
- * Retrieve a fiber from the FiberMap.
+ * Retrieves a fiber from the FiberMap effectfully.
  *
  * **Details**
  *
@@ -377,7 +377,7 @@ export const getUnsafe = /*#__PURE__*/dual(2, (self, key) => {
  */
 export const get = /*#__PURE__*/dual(2, (self, key) => Effect.suspend(() => Effect.succeed(getUnsafe(self, key))));
 /**
- * Check if a key exists in the FiberMap.
+ * Checks whether a key exists in the FiberMap.
  *
  * **Example** (Checking if a key exists unsafely)
  *
@@ -401,7 +401,7 @@ export const get = /*#__PURE__*/dual(2, (self, key) => Effect.suspend(() => Effe
  */
 export const hasUnsafe = /*#__PURE__*/dual(2, (self, key) => self.state._tag === "Closed" ? false : MutableHashMap.has(self.state.backing, key));
 /**
- * Check if a key exists in the FiberMap.
+ * Checks whether a key exists in the FiberMap.
  * This is the Effect-wrapped version of `hasUnsafe`.
  *
  * **Example** (Checking if a key exists)
@@ -429,7 +429,7 @@ export const hasUnsafe = /*#__PURE__*/dual(2, (self, key) => self.state._tag ===
  */
 export const has = /*#__PURE__*/dual(2, (self, key) => Effect.sync(() => hasUnsafe(self, key)));
 /**
- * Remove a fiber from the FiberMap, interrupting it if it exists.
+ * Removes a fiber from the FiberMap, interrupting it if it exists.
  *
  * **Example** (Removing a fiber)
  *
@@ -466,7 +466,7 @@ export const remove = /*#__PURE__*/dual(2, (self, key) => Effect.suspend(() => {
   return Fiber.interruptAs(fiber.value, internalFiberId);
 }));
 /**
- * Remove all fibers from the FiberMap, interrupting them.
+ * Removes all fibers from the FiberMap, interrupting them.
  *
  * **Example** (Clearing all fibers)
  *
@@ -651,7 +651,7 @@ export const runtimePromise = self => () => Effect.map(runtime(self)(), runFork
   }
 })));
 /**
- * Get the number of fibers currently in the FiberMap.
+ * Gets the number of fibers currently in the FiberMap.
  *
  * **Example** (Checking the map size)
  *
@@ -704,7 +704,7 @@ export const size = self => Effect.sync(() => self.state._tag === "Closed" ? 0 :
  */
 export const join = self => Deferred.await(self.deferred);
 /**
- * Wait for the FiberMap to be empty.
+ * Waits for the FiberMap to be empty.
  * This will wait for all currently running fibers to complete.
  *
  * **Example** (Waiting for an empty map)