effect 3.12.4 → 3.12.6

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/dateTime.ts

@@ -234,6 +234,9 @@ export const unsafeMake = <A extends DateTime.DateTime.Input>(input: A): DateTim
   return unsafeFromDate(new Date(input)) as DateTime.DateTime.PreserveZone<A>
 }
 
+const minEpochMillis = -8640000000000000 + (12 * 60 * 60 * 1000)
+const maxEpochMillis = 8640000000000000 - (14 * 60 * 60 * 1000)
+
 /** @internal */
 export const unsafeMakeZoned = (input: DateTime.DateTime.Input, options?: {
   readonly timeZone?: number | string | DateTime.TimeZone | undefined
@@ -243,6 +246,9 @@ export const unsafeMakeZoned = (input: DateTime.DateTime.Input, options?: {
     return input
   }
   const self = unsafeMake(input)
+  if (self.epochMillis < minEpochMillis || self.epochMillis > maxEpochMillis) {
+    throw new IllegalArgumentException(`Epoch millis out of range: ${self.epochMillis}`)
+  }
   let zone: DateTime.TimeZone
   if (options?.timeZone === undefined) {
     const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1000
@@ -568,8 +574,12 @@ export const zonedOffset = (self: DateTime.Zoned): number => {
 
 const offsetToString = (offset: number): string => {
   const abs = Math.abs(offset)
-  const hours = Math.floor(abs / (60 * 60 * 1000))
-  const minutes = Math.round((abs % (60 * 60 * 1000)) / (60 * 1000))
+  let hours = Math.floor(abs / (60 * 60 * 1000))
+  let minutes = Math.round((abs % (60 * 60 * 1000)) / (60 * 1000))
+  if (minutes === 60) {
+    hours += 1
+    minutes = 0
+  }
   return `${offset < 0 ? "-" : "+"}${String(hours).padStart(2, "0")}:${String(minutes).padStart(2, "0")}`
 }
 

package/src/internal/effect/circular.ts

@@ -27,7 +27,6 @@ import type * as Types from "../../Types.js"
 import * as internalCause from "../cause.js"
 import * as effect from "../core-effect.js"
 import * as core from "../core.js"
-import * as executionStrategy from "../executionStrategy.js"
 import * as internalFiber from "../fiber.js"
 import * as fiberRuntime from "../fiberRuntime.js"
 import { globalScope } from "../fiberScope.js"
@@ -362,23 +361,26 @@ export const forkIn = dual<
 >(
   2,
   (self, scope) =>
-    core.uninterruptibleMask((restore) =>
-      core.flatMap(scope.fork(executionStrategy.sequential), (child) =>
-        pipe(
-          restore(self),
-          core.onExit((exit) => child.close(exit)),
-          fiberRuntime.forkDaemon,
-          core.tap((fiber) =>
-            child.addFinalizer(() =>
-              core.fiberIdWith((fiberId) =>
-                Equal.equals(fiberId, fiber.id()) ?
-                  core.void :
-                  core.asVoid(core.interruptFiber(fiber))
-              )
-            )
+    core.withFiberRuntime((parent, parentStatus) => {
+      const scopeImpl = scope as fiberRuntime.ScopeImpl
+      const fiber = fiberRuntime.unsafeFork(self, parent, parentStatus.runtimeFlags, globalScope)
+      if (scopeImpl.state._tag === "Open") {
+        const finalizer = () =>
+          core.fiberIdWith((fiberId) =>
+            Equal.equals(fiberId, fiber.id()) ?
+              core.void :
+              core.asVoid(core.interruptFiber(fiber))
           )
-        ))
-    )
+        scopeImpl.state.finalizers.add(finalizer)
+        fiber.addObserver(() => {
+          if (scopeImpl.state._tag === "Closed") return
+          scopeImpl.state.finalizers.delete(finalizer)
+        })
+      } else {
+        fiber.unsafeInterruptAsFork(parent.id())
+      }
+      return core.succeed(fiber)
+    })
 )
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -3207,7 +3207,8 @@ export const scopeTag = Context.GenericTag<Scope.Scope>("effect/Scope")
 /* @internal */
 export const scope: Effect.Effect<Scope.Scope, never, Scope.Scope> = scopeTag
 
-interface ScopeImpl extends Scope.CloseableScope {
+/** @internal */
+export interface ScopeImpl extends Scope.CloseableScope {
   state: {
     readonly _tag: "Open"
     readonly finalizers: Set<Scope.Scope.Finalizer>

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),

package/src/internal/runtime.ts

@@ -165,23 +165,15 @@ class FiberFailureImpl extends Error implements Runtime.FiberFailure {
   readonly [FiberFailureId]: Runtime.FiberFailureId
   readonly [FiberFailureCauseId]: Cause.Cause<unknown>
   constructor(cause: Cause.Cause<unknown>) {
-    super()
+    const head = InternalCause.prettyErrors(cause)[0]
 
+    super(head?.message || "An error has occurred")
     this[FiberFailureId] = FiberFailureId
     this[FiberFailureCauseId] = cause
 
-    const prettyErrors = InternalCause.prettyErrors(cause)
-    if (prettyErrors.length > 0) {
-      const head = prettyErrors[0]
-      this.name = head.name
-      this.message = head.message
-      this.stack = head.stack!
-    }
-
-    this.name = `(FiberFailure) ${this.name}`
-
-    if (this.message === undefined || this.message.length === 0) {
-      this.message = "An error has occurred"
+    this.name = head ? `(FiberFailure) ${head.name}` : "FiberFailure"
+    if (head?.stack) {
+      this.stack = head.stack
     }
   }
 
@@ -193,7 +185,7 @@ class FiberFailureImpl extends Error implements Runtime.FiberFailure {
   }
 
   toString(): string {
-    return "(FiberFailure) " + (this.stack ?? this.message)
+    return "(FiberFailure) " + InternalCause.pretty(this[FiberFailureCauseId], { renderErrorCause: true })
   }
   [Inspectable.NodeInspectSymbol](): unknown {
     return this.toString()

package/src/internal/stream.ts

@@ -2111,7 +2111,7 @@ export const distributedWithDynamicCallback = dual<
       (ref, _) => pipe(Ref.get(ref), Effect.flatMap((queues) => pipe(queues.values(), Effect.forEach(Queue.shutdown))))
     ),
     Effect.flatMap((queuesRef) =>
-      Effect.gen(function*($) {
+      Effect.gen(function*() {
         const offer = (a: A): Effect.Effect<void> =>
           pipe(
             decide(a),
@@ -2157,19 +2157,17 @@ export const distributedWithDynamicCallback = dual<
             ),
             Effect.asVoid
           )
-        const queuesLock = yield* $(Effect.makeSemaphore(1))
-        const newQueue = yield* $(
-          Ref.make<Effect.Effect<[number, Queue.Queue<Exit.Exit<A, Option.Option<E>>>]>>(
-            pipe(
-              Queue.bounded<Exit.Exit<A, Option.Option<E>>>(maximumLag),
-              Effect.flatMap((queue) => {
-                const id = newDistributedWithDynamicId()
-                return pipe(
-                  Ref.update(queuesRef, (map) => map.set(id, queue)),
-                  Effect.as([id, queue])
-                )
-              })
-            )
+        const queuesLock = yield* Effect.makeSemaphore(1)
+        const newQueue = yield* Ref.make<Effect.Effect<[number, Queue.Queue<Exit.Exit<A, Option.Option<E>>>]>>(
+          pipe(
+            Queue.bounded<Exit.Exit<A, Option.Option<E>>>(maximumLag),
+            Effect.flatMap((queue) => {
+              const id = newDistributedWithDynamicId()
+              return pipe(
+                Ref.update(queuesRef, (map) => map.set(id, queue)),
+                Effect.as([id, queue])
+              )
+            })
           )
         )
         const finalize = (endTake: Exit.Exit<never, Option.Option<E>>): Effect.Effect<void> =>
@@ -2213,7 +2211,7 @@ export const distributedWithDynamicCallback = dual<
               Effect.asVoid
             )
           )
-        yield* $(
+        yield* pipe(
           self,
           runForEachScoped(offer),
           Effect.matchCauseEffect({

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.12.4"
+let moduleVersion = "3.12.6"
 
 export const getCurrentVersion = () => moduleVersion