effect 3.12.5 → 3.12.6

package/src/LogLevel.ts

@@ -171,24 +171,108 @@ export const None: LogLevel = core.logLevelNone
 export const allLevels = core.allLogLevels
 
 /**
- * Locally applies the specified `LogLevel` to an `Effect` workflow, reverting
- * to the previous `LogLevel` after the `Effect` workflow completes.
+ * Temporarily sets a `LogLevel` for an `Effect` workflow.
+ *
+ * **Details**
+ *
+ * This function allows you to apply a specific `LogLevel` locally to an
+ * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its
+ * previous state.
+ *
+ * **When to Use**
+ *
+ * This is particularly useful when you want to adjust the verbosity of logging
+ * for specific parts of your program without affecting the global log level.
+ *
+ * @example
+ * ```ts
+ * import { Effect, LogLevel } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   yield* Effect.log("message1")
+ *   yield* Effect.gen(function*() {
+ *     yield* Effect.log("message2")
+ *     yield* Effect.log("message3")
+ *   }).pipe(LogLevel.locally(LogLevel.Warning))
+ * })
+ *
+ * // Effect.runFork(program)
+ * // timestamp=... level=INFO fiber=#0 message=message1
+ * // timestamp=... level=WARN fiber=#0 message=message2
+ * // timestamp=... level=WARN fiber=#0 message=message3
+ * ```
  *
  * @since 2.0.0
  * @category utils
  */
 export const locally: {
   /**
-   * Locally applies the specified `LogLevel` to an `Effect` workflow, reverting
-   * to the previous `LogLevel` after the `Effect` workflow completes.
+   * Temporarily sets a `LogLevel` for an `Effect` workflow.
+   *
+   * **Details**
+   *
+   * This function allows you to apply a specific `LogLevel` locally to an
+   * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its
+   * previous state.
+   *
+   * **When to Use**
+   *
+   * This is particularly useful when you want to adjust the verbosity of logging
+   * for specific parts of your program without affecting the global log level.
+   *
+   * @example
+   * ```ts
+   * import { Effect, LogLevel } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   yield* Effect.log("message1")
+   *   yield* Effect.gen(function*() {
+   *     yield* Effect.log("message2")
+   *     yield* Effect.log("message3")
+   *   }).pipe(LogLevel.locally(LogLevel.Warning))
+   * })
+   *
+   * // Effect.runFork(program)
+   * // timestamp=... level=INFO fiber=#0 message=message1
+   * // timestamp=... level=WARN fiber=#0 message=message2
+   * // timestamp=... level=WARN fiber=#0 message=message3
+   * ```
    *
    * @since 2.0.0
    * @category utils
    */
   (self: LogLevel): <A, E, R>(use: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>
   /**
-   * Locally applies the specified `LogLevel` to an `Effect` workflow, reverting
-   * to the previous `LogLevel` after the `Effect` workflow completes.
+   * Temporarily sets a `LogLevel` for an `Effect` workflow.
+   *
+   * **Details**
+   *
+   * This function allows you to apply a specific `LogLevel` locally to an
+   * `Effect` workflow. Once the workflow completes, the `LogLevel` reverts to its
+   * previous state.
+   *
+   * **When to Use**
+   *
+   * This is particularly useful when you want to adjust the verbosity of logging
+   * for specific parts of your program without affecting the global log level.
+   *
+   * @example
+   * ```ts
+   * import { Effect, LogLevel } from "effect"
+   *
+   * const program = Effect.gen(function*() {
+   *   yield* Effect.log("message1")
+   *   yield* Effect.gen(function*() {
+   *     yield* Effect.log("message2")
+   *     yield* Effect.log("message3")
+   *   }).pipe(LogLevel.locally(LogLevel.Warning))
+   * })
+   *
+   * // Effect.runFork(program)
+   * // timestamp=... level=INFO fiber=#0 message=message1
+   * // timestamp=... level=WARN fiber=#0 message=message2
+   * // timestamp=... level=WARN fiber=#0 message=message3
+   * ```
    *
    * @since 2.0.0
    * @category utils

package/src/ParseResult.ts

@@ -1419,9 +1419,10 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
     case "Union": {
       const searchTree = getSearchTree(ast.types, isDecoding)
       const ownKeys = util_.ownKeys(searchTree.keys)
-      const len = ownKeys.length
+      const ownKeysLen = ownKeys.length
+      const astTypesLen = ast.types.length
       const map = new Map<any, Parser>()
-      for (let i = 0; i < ast.types.length; i++) {
+      for (let i = 0; i < astTypesLen; i++) {
         map.set(ast.types[i], goMemo(ast.types[i], isDecoding))
       }
       const concurrency = getConcurrency(ast) ?? 1
@@ -1430,9 +1431,9 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
         const es: Array<[number, ParseIssue]> = []
         let stepKey = 0
         let candidates: Array<AST.AST> = []
-        if (len > 0) {
+        if (ownKeysLen > 0) {
           if (Predicate.isRecordOrArray(input)) {
-            for (let i = 0; i < len; i++) {
+            for (let i = 0; i < ownKeysLen; i++) {
               const name = ownKeys[i]
               const buckets = searchTree.keys[name].buckets
               // for each property that should contain a literal, check if the input contains that property
@@ -1443,33 +1444,33 @@ const go = (ast: AST.AST, isDecoding: boolean): Parser => {
                   // retrive the minimal set of candidates for decoding
                   candidates = candidates.concat(buckets[literal])
                 } else {
-                  const literals = AST.Union.make(searchTree.keys[name].literals)
+                  const { candidates, literals } = searchTree.keys[name]
+                  const literalsUnion = AST.Union.make(literals)
+                  const errorAst = candidates.length === astTypesLen
+                    ? new AST.TypeLiteral([new AST.PropertySignature(name, literalsUnion, false, true)], [])
+                    : AST.Union.make(candidates)
                   es.push([
                     stepKey++,
-                    new Composite(
-                      new AST.TypeLiteral([
-                        new AST.PropertySignature(name, literals, false, true)
-                      ], []),
-                      input,
-                      new Pointer(name, input, new Type(literals, input[name]))
-                    )
+                    new Composite(errorAst, input, new Pointer(name, input, new Type(literalsUnion, input[name])))
                   ])
                 }
               } else {
-                const literals = AST.Union.make(searchTree.keys[name].literals)
-                const fakeps = new AST.PropertySignature(name, literals, false, true)
+                const { candidates, literals } = searchTree.keys[name]
+                const fakePropertySignature = new AST.PropertySignature(name, AST.Union.make(literals), false, true)
+                const errorAst = candidates.length === astTypesLen
+                  ? new AST.TypeLiteral([fakePropertySignature], [])
+                  : AST.Union.make(candidates)
                 es.push([
                   stepKey++,
-                  new Composite(
-                    new AST.TypeLiteral([fakeps], []),
-                    input,
-                    new Pointer(name, input, new Missing(fakeps))
-                  )
+                  new Composite(errorAst, input, new Pointer(name, input, new Missing(fakePropertySignature)))
                 ])
               }
             }
           } else {
-            es.push([stepKey++, new Type(ast, input)])
+            const errorAst = searchTree.candidates.length === astTypesLen
+              ? ast
+              : AST.Union.make(searchTree.candidates)
+            es.push([stepKey++, new Type(errorAst, input)])
           }
         }
         if (searchTree.otherwise.length > 0) {
@@ -1608,16 +1609,19 @@ export const getLiterals = (
 }
 
 /**
- * The purpose of the algorithm is to narrow down the pool of possible candidates for decoding as much as possible.
+ * The purpose of the algorithm is to narrow down the pool of possible
+ * candidates for decoding as much as possible.
  *
  * This function separates the schemas into two groups, `keys` and `otherwise`:
  *
  * - `keys`: the schema has at least one property with a literal value
  * - `otherwise`: the schema has no properties with a literal value
  *
- * If a schema has at least one property with a literal value, so it ends up in `keys`, first a namespace is created for
- * the name of the property containing the literal, and then within this namespace a "bucket" is created for the literal
- * value in which to store all the schemas that have the same property and literal value.
+ * If a schema has at least one property with a literal value, so it ends up in
+ * `keys`, first a namespace is created for the name of the property containing
+ * the literal, and then within this namespace a "bucket" is created for the
+ * literal value in which to store all the schemas that have the same property
+ * and literal value.
  *
  * @internal
  */
@@ -1629,25 +1633,30 @@ export const getSearchTree = (
     readonly [key: PropertyKey]: {
       buckets: { [literal: string]: ReadonlyArray<AST.AST> }
       literals: ReadonlyArray<AST.Literal> // this is for error messages
+      candidates: ReadonlyArray<AST.AST>
     }
   }
   otherwise: ReadonlyArray<AST.AST>
+  candidates: ReadonlyArray<AST.AST>
 } => {
   const keys: {
     [key: PropertyKey]: {
       buckets: { [literal: string]: Array<AST.AST> }
       literals: Array<AST.Literal>
+      candidates: Array<AST.AST>
     }
   } = {}
   const otherwise: Array<AST.AST> = []
+  const candidates: Array<AST.AST> = []
   for (let i = 0; i < members.length; i++) {
     const member = members[i]
     const tags = getLiterals(member, isDecoding)
     if (tags.length > 0) {
+      candidates.push(member)
       for (let j = 0; j < tags.length; j++) {
         const [key, literal] = tags[j]
         const hash = String(literal.literal)
-        keys[key] = keys[key] || { buckets: {}, literals: [] }
+        keys[key] = keys[key] || { buckets: {}, literals: [], candidates: [] }
         const buckets = keys[key].buckets
         if (Object.prototype.hasOwnProperty.call(buckets, hash)) {
           if (j < tags.length - 1) {
@@ -1655,9 +1664,11 @@ export const getSearchTree = (
           }
           buckets[hash].push(member)
           keys[key].literals.push(literal)
+          keys[key].candidates.push(member)
         } else {
           buckets[hash] = [member]
           keys[key].literals.push(literal)
+          keys[key].candidates.push(member)
           break
         }
       }
@@ -1665,7 +1676,7 @@ export const getSearchTree = (
       otherwise.push(member)
     }
   }
-  return { keys, otherwise }
+  return { keys, otherwise, candidates }
 }
 
 const dropRightRefinement = (ast: AST.AST): AST.AST => AST.isRefinement(ast) ? dropRightRefinement(ast.from) : ast

package/src/Schema.ts

@@ -3016,9 +3016,7 @@ export const pluck: {
    * @category struct transformations
    * @since 3.10.0
    */
-  <A, I, K extends keyof A & keyof I>(
-    key: K
-  ): <R>(schema: Schema<A, I, R>) => Schema<A[K], { readonly [P in K]: I[P] }, R>
+  <A, I, K extends keyof A & keyof I>(key: K): <R>(schema: Schema<A, I, R>) => Schema<A[K], Simplify<Pick<I, K>>, R>
   /**
    * Given a schema `Schema<A, I, R>` and a key `key: K`, this function extracts a specific field from the `A` type,
    * producing a new schema that represents a transformation from the `{ readonly [key]: I[K] }` type to `A[K]`.
@@ -3049,7 +3047,7 @@ export const pluck: {
    * @category struct transformations
    * @since 3.10.0
    */
-  <A, I, R, K extends keyof A & keyof I>(schema: Schema<A, I, R>, key: K): Schema<A[K], { readonly [P in K]: I[P] }, R>
+  <A, I, R, K extends keyof A & keyof I>(schema: Schema<A, I, R>, key: K): Schema<A[K], Simplify<Pick<I, K>>, R>
 } = dual(
   2,
   <A, I, R, K extends keyof A & keyof I>(
@@ -3722,7 +3720,8 @@ export type RefineSchemaId = typeof RefineSchemaId
 export interface refine<A, From extends Schema.Any>
   extends AnnotableClass<refine<A, From>, A, Schema.Encoded<From>, Schema.Context<From>>
 {
-  readonly [RefineSchemaId]: From // required for `type HasFields = ...`
+  /** The following is required for {@link HasFields} to work */
+  readonly [RefineSchemaId]: From
   readonly from: From
   readonly filter: (
     a: Schema.Type<From>,
@@ -6030,7 +6029,7 @@ export const NonNegativeBigInt: filter<Schema<bigint, string>> = BigInt$.pipe(
  */
 export class BigIntFromNumber extends transformOrFail(
   Number$.annotations({ description: "a number to be decoded into a bigint" }),
-  BigIntFromSelf,
+  BigIntFromSelf.pipe(betweenBigInt(BigInt(Number.MIN_SAFE_INTEGER), BigInt(Number.MAX_SAFE_INTEGER))),
   {
     strict: true,
     decode: (n, _, ast) =>
@@ -6147,29 +6146,23 @@ export class DurationFromSelf extends declare(
     arbitrary: (): LazyArbitrary<duration_.Duration> => (fc) =>
       fc.oneof(
         fc.constant(duration_.infinity),
-        fc.bigUint().map((_) => duration_.nanos(_)),
-        fc.bigUint().map((_) => duration_.micros(_)),
-        fc.maxSafeNat().map((_) => duration_.millis(_)),
-        fc.maxSafeNat().map((_) => duration_.seconds(_)),
-        fc.maxSafeNat().map((_) => duration_.minutes(_)),
-        fc.maxSafeNat().map((_) => duration_.hours(_)),
-        fc.maxSafeNat().map((_) => duration_.days(_)),
-        fc.maxSafeNat().map((_) => duration_.weeks(_))
+        fc.bigInt({ min: 0n }).map((_) => duration_.nanos(_)),
+        fc.maxSafeNat().map((_) => duration_.millis(_))
       ),
     equivalence: (): Equivalence.Equivalence<duration_.Duration> => duration_.Equivalence
   }
 ) {}
 
 /**
- * A schema that transforms a `bigint` tuple into a `Duration`.
- * Treats the value as the number of nanoseconds.
+ * A schema that transforms a non negative `bigint` into a `Duration`. Treats
+ * the value as the number of nanoseconds.
  *
  * @category Duration transformations
  * @since 3.10.0
  */
 export class DurationFromNanos extends transformOrFail(
-  BigIntFromSelf.annotations({ description: "a bigint to be decoded into a Duration" }),
-  DurationFromSelf,
+  NonNegativeBigIntFromSelf.annotations({ description: "a bigint to be decoded into a Duration" }),
+  DurationFromSelf.pipe(filter((duration) => duration_.isFinite(duration), { description: "a finite duration" })),
   {
     strict: true,
     decode: (nanos) => ParseResult.succeed(duration_.nanos(nanos)),
@@ -6177,48 +6170,66 @@ export class DurationFromNanos extends transformOrFail(
       option_.match(duration_.toNanos(duration), {
         onNone: () =>
           ParseResult.fail(new ParseResult.Type(ast, duration, `Unable to encode ${duration} into a bigint`)),
-        onSome: (val) => ParseResult.succeed(val)
+        onSome: (nanos) => ParseResult.succeed(nanos)
       })
   }
 ).annotations({ identifier: "DurationFromNanos" }) {}
 
 /**
- * A schema that transforms a `number` tuple into a `Duration`.
- * Treats the value as the number of milliseconds.
+ * A non-negative integer. +Infinity is excluded.
+ *
+ * @category number constructors
+ * @since 3.11.10
+ */
+export const NonNegativeInt = NonNegative.pipe(int()).annotations({ identifier: "NonNegativeInt" })
+
+/**
+ * A schema that transforms a (possibly Infinite) non negative number into a
+ * `Duration`. Treats the value as the number of milliseconds.
  *
  * @category Duration transformations
  * @since 3.10.0
  */
 export class DurationFromMillis extends transform(
-  Number$.annotations({ description: "a number to be decoded into a Duration" }),
+  NonNegative.annotations({
+    description: "a non-negative number to be decoded into a Duration"
+  }),
   DurationFromSelf,
-  { strict: true, decode: (ms) => duration_.millis(ms), encode: (n) => duration_.toMillis(n) }
+  {
+    strict: true,
+    decode: (ms) => duration_.millis(ms),
+    encode: (duration) => duration_.toMillis(duration)
+  }
 ).annotations({ identifier: "DurationFromMillis" }) {}
 
-/**
- * @category number constructors
- * @since 3.11.10
- */
-export const NonNegativeInt = NonNegative.pipe(int()).annotations({ identifier: "NonNegativeInt" })
-
-const HRTime: Schema<readonly [seconds: number, nanos: number]> = Tuple(
+const FiniteHRTime = Tuple(
   element(NonNegativeInt).annotations({ title: "seconds" }),
   element(NonNegativeInt).annotations({ title: "nanos" })
-).annotations({ identifier: "HRTime" })
+).annotations({ identifier: "FiniteHRTime" })
+
+const InfiniteHRTime = Tuple(Literal(-1), Literal(0)).annotations({ identifier: "InfiniteHRTime" })
+
+const HRTime: Schema<readonly [seconds: number, nanos: number]> = Union(FiniteHRTime, InfiniteHRTime).annotations({
+  identifier: "HRTime",
+  description: "a tuple of seconds and nanos to be decoded into a Duration"
+})
 
 /**
  * A schema that transforms a `[number, number]` tuple into a `Duration`.
  *
+ * Infinite durations are encoded as `[-1, 0]`.
+ *
  * @category Duration transformations
  * @since 3.10.0
  */
 export class Duration extends transform(
-  HRTime.annotations({ description: "a tuple of seconds and nanos to be decoded into a Duration" }),
+  HRTime,
   DurationFromSelf,
   {
     strict: true,
-    decode: ([seconds, nanos]) => duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos)),
-    encode: (duration) => duration_.toHrTime(duration)
+    decode: ([seconds, nanos]) =>
+      seconds === -1 ? duration_.infinity : duration_.nanos(BigInt(seconds) * BigInt(1e9) + BigInt(nanos)),
+    encode: (duration) => duration.value._tag === "Infinity" ? [-1, 0] as const : duration_.toHrTime(duration)
   }
 ).annotations({ identifier: "Duration" }) {}
 

package/src/internal/cause.ts

@@ -132,7 +132,7 @@ export const sequential = <E, E2>(left: Cause.Cause<E>, right: Cause.Cause<E2>):
 // -----------------------------------------------------------------------------
 
 /** @internal */
-export const isCause = (u: unknown): u is Cause.Cause<never> => hasProperty(u, CauseTypeId)
+export const isCause = (u: unknown): u is Cause.Cause<unknown> => hasProperty(u, CauseTypeId)
 
 /** @internal */
 export const isEmptyType = <E>(self: Cause.Cause<E>): self is Cause.Empty => self._tag === OpCodes.OP_EMPTY

package/src/internal/core-effect.ts

@@ -103,7 +103,11 @@ export const try_: {
     try {
       return core.succeed(internalCall(evaluate))
     } catch (error) {
-      return core.fail(onFailure ? internalCall(() => onFailure(error)) : new core.UnknownException(error))
+      return core.fail(
+        onFailure
+          ? internalCall(() => onFailure(error))
+          : new core.UnknownException(error, "An unknown error occurred in Effect.try")
+      )
     }
   })
 }
@@ -1644,17 +1648,20 @@ export const tryPromise: {
     evaluate = arg.try as (signal?: AbortSignal) => PromiseLike<A>
     catcher = arg.catch
   }
+  const fail = (e: unknown) =>
+    catcher
+      ? core.failSync(() => catcher(e))
+      : core.fail(new core.UnknownException(e, "An unknown error occurred in Effect.tryPromise"))
 
   if (evaluate.length >= 1) {
     return core.async((resolve, signal) => {
       try {
-        evaluate(signal)
-          .then(
-            (a) => resolve(core.exitSucceed(a)),
-            (e) => resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
-          )
+        evaluate(signal).then(
+          (a) => resolve(core.exitSucceed(a)),
+          (e) => resolve(fail(e))
+        )
       } catch (e) {
-        resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
+        resolve(fail(e))
       }
     })
   }
@@ -1664,10 +1671,10 @@ export const tryPromise: {
       evaluate()
         .then(
           (a) => resolve(core.exitSucceed(a)),
-          (e) => resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
+          (e) => resolve(fail(e))
         )
     } catch (e) {
-      resolve(catcher ? core.failSync(() => catcher(e)) : core.fail(new core.UnknownException(e)))
+      resolve(fail(e))
     }
   })
 }

package/src/internal/core.ts

@@ -797,7 +797,8 @@ export const andThen: {
       return b
     } else if (isPromiseLike(b)) {
       return unsafeAsync<any, Cause.UnknownException>((resume) => {
-        b.then((a) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
+        b.then((a) => resume(succeed(a)), (e) =>
+          resume(fail(new UnknownException(e, "An unknown error occurred in Effect.andThen"))))
       })
     }
     return succeed(b)
@@ -1281,7 +1282,8 @@ export const tap = dual<
         return as(b, a)
       } else if (isPromiseLike(b)) {
         return unsafeAsync<any, Cause.UnknownException>((resume) => {
-          b.then((_) => resume(succeed(a)), (e) => resume(fail(new UnknownException(e))))
+          b.then((_) => resume(succeed(a)), (e) =>
+            resume(fail(new UnknownException(e, "An unknown error occurred in Effect.tap"))))
         })
       }
       return succeed(a)
@@ -2208,7 +2210,10 @@ export const YieldableError: new(message?: string, options?: ErrorOptions) => Ca
       return fail(this)
     }
     toJSON() {
-      return { ...this }
+      const obj = { ...this }
+      if (this.message) obj.message = this.message
+      if (this.cause) obj.cause = this.cause
+      return obj
     }
     [NodeInspectSymbol]() {
       if (this.toString !== globalThis.Error.prototype.toString) {
@@ -2345,7 +2350,7 @@ export const UnknownException: new(cause: unknown, message?: string | undefined)
     class UnknownException extends YieldableError {
       readonly _tag = "UnknownException"
       readonly error: unknown
-      constructor(readonly cause: unknown, message?: string) {
+      constructor(cause: unknown, message?: string) {
         super(message ?? "An unknown error occurred", { cause })
         this.error = cause
       }

package/src/internal/groupBy.ts

@@ -152,18 +152,16 @@ export const groupBy = dual<
   ): GroupBy.GroupBy<K, V, E | E2, R | R2> =>
     make(
       stream.unwrapScoped(
-        Effect.gen(function*($) {
-          const decider = yield* $(
-            Deferred.make<(key: K, value: V) => Effect.Effect<Predicate<number>>>()
-          )
-          const output = yield* $(Effect.acquireRelease(
+        Effect.gen(function*() {
+          const decider = yield* Deferred.make<(key: K, value: V) => Effect.Effect<Predicate<number>>>()
+          const output = yield* Effect.acquireRelease(
             Queue.bounded<Exit.Exit<readonly [K, Queue.Dequeue<Take.Take<V, E | E2>>], Option.Option<E | E2>>>(
               options?.bufferSize ?? 16
             ),
             (queue) => Queue.shutdown(queue)
-          ))
-          const ref = yield* $(Ref.make<Map<K, number>>(new Map()))
-          const add = yield* $(
+          )
+          const ref = yield* Ref.make<Map<K, number>>(new Map())
+          const add = yield* pipe(
             stream.mapEffectSequential(self, f),
             stream.distributedWithDynamicCallback(
               options?.bufferSize ?? 16,
@@ -171,37 +169,35 @@ export const groupBy = dual<
               (exit) => Queue.offer(output, exit)
             )
           )
-          yield* $(
-            Deferred.succeed(decider, (key, _) =>
-              pipe(
-                Ref.get(ref),
-                Effect.map((map) => Option.fromNullable(map.get(key))),
-                Effect.flatMap(Option.match({
-                  onNone: () =>
-                    Effect.flatMap(add, ([index, queue]) =>
-                      Effect.zipRight(
-                        Ref.update(ref, (map) => map.set(key, index)),
-                        pipe(
-                          Queue.offer(
-                            output,
-                            Exit.succeed(
-                              [
-                                key,
-                                mapDequeue(queue, (exit) =>
-                                  new take.TakeImpl(pipe(
-                                    exit,
-                                    Exit.map((tuple) => Chunk.of(tuple[1]))
-                                  )))
-                              ] as const
-                            )
-                          ),
-                          Effect.as<Predicate<number>>((n: number) => n === index)
-                        )
-                      )),
-                  onSome: (index) => Effect.succeed<Predicate<number>>((n: number) => n === index)
-                }))
-              ))
-          )
+          yield* Deferred.succeed(decider, (key, _) =>
+            pipe(
+              Ref.get(ref),
+              Effect.map((map) => Option.fromNullable(map.get(key))),
+              Effect.flatMap(Option.match({
+                onNone: () =>
+                  Effect.flatMap(add, ([index, queue]) =>
+                    Effect.zipRight(
+                      Ref.update(ref, (map) => map.set(key, index)),
+                      pipe(
+                        Queue.offer(
+                          output,
+                          Exit.succeed(
+                            [
+                              key,
+                              mapDequeue(queue, (exit) =>
+                                new take.TakeImpl(pipe(
+                                  exit,
+                                  Exit.map((tuple) => Chunk.of(tuple[1]))
+                                )))
+                            ] as const
+                          )
+                        ),
+                        Effect.as<Predicate<number>>((n: number) => n === index)
+                      )
+                    )),
+                onSome: (index) => Effect.succeed<Predicate<number>>((n: number) => n === index)
+              }))
+            ))
           return stream.flattenExitOption(stream.fromQueue(output, { shutdown: true }))
         })
       )

package/src/internal/rateLimiter.ts

@@ -2,6 +2,7 @@ import type { DurationInput } from "../Duration.js"
 import * as Duration from "../Duration.js"
 import * as Effect from "../Effect.js"
 import * as FiberRef from "../FiberRef.js"
+import { pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
 import type * as RateLimiter from "../RateLimiter.js"
 import type * as Scope from "../Scope.js"
@@ -31,16 +32,16 @@ const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
   never,
   Scope.Scope
 > =>
-  Effect.gen(function*(_) {
+  Effect.gen(function*() {
     const millisPerToken = Math.ceil(Duration.toMillis(window) / limit)
-    const semaphore = yield* _(Effect.makeSemaphore(limit))
+    const semaphore = yield* Effect.makeSemaphore(limit)
     const latch = yield* Effect.makeSemaphore(0)
     const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
       Effect.zipRight(latch.releaseAll),
       Effect.zipRight(semaphore.release(1)),
       Effect.flatMap((free) => free === limit ? Effect.void : refill)
     )
-    yield* _(
+    yield* pipe(
       latch.take(1),
       Effect.zipRight(refill),
       Effect.forever,
@@ -61,10 +62,10 @@ const fixedWindow = (limit: number, window: DurationInput): Effect.Effect<
   never,
   Scope.Scope
 > =>
-  Effect.gen(function*(_) {
-    const semaphore = yield* _(Effect.makeSemaphore(limit))
-    const latch = yield* _(Effect.makeSemaphore(0))
-    yield* _(
+  Effect.gen(function*() {
+    const semaphore = yield* Effect.makeSemaphore(limit)
+    const latch = yield* Effect.makeSemaphore(0)
+    yield* pipe(
       latch.take(1),
       Effect.zipRight(Effect.sleep(window)),
       Effect.zipRight(latch.releaseAll),