effect 4.0.1 → 4.0.3

package/src/internal/arbitrary/array.ts

@@ -54,13 +54,13 @@ function rebuild<A>(
         }
         if (index >= elementStart) itemShrinks ??= children[index].shrinks?.()
         if (itemShrinks !== undefined) {
-          return Effect.matchEffect(itemShrinks, {
-            onFailure: () => {
+          return Effect.matchCauseEffect(itemShrinks, {
+            onFailure: Model.onTypedFailure(() => {
               itemShrinks = undefined
               removable = undefined
               index++
               return loop()
-            },
+            }),
             onSuccess: (item): Effect.Effect<Model.Attempt<Array<A>>> => {
               if (item._tag === "Discarded") return Effect.succeed(item)
               return Effect.succeed(rebuild(InternalArray.replaceAt(children, index, item), shape, index))

package/src/internal/arbitrary/model.ts

@@ -1,12 +1,32 @@
-import type * as Cause from "../../Cause.ts"
+import * as Cause from "../../Cause.ts"
 import * as Effect from "../../Effect.ts"
 import * as Option from "../../Option.ts"
+import * as Result from "../../Result.ts"
 import * as InternalArray from "../array.ts"
 import { done } from "../core.ts"
 
 /** @internal */
 export type ShrinkPull<A> = Effect.Effect<A, Cause.Done>
 
+/**
+ * Builds a cause handler that recovers typed failures, or propagates only
+ * defects and interruptions, preserving their original annotations.
+ *
+ * @internal
+ */
+export const onTypedFailure = <E, A, E2, R>(
+  f: (error: E) => Effect.Effect<A, E2, R>
+) =>
+(cause: Cause.Cause<E>): Effect.Effect<A, E2, R> => {
+  if (!cause.reasons.every(Cause.isFailReason)) {
+    return Effect.failCause(Cause.fromReasons<never>(cause.reasons.filter(
+      (reason): reason is Cause.Die | Cause.Interrupt => reason._tag !== "Fail"
+    )))
+  }
+  const error = Cause.findError(cause)
+  return Result.isFailure(error) ? Effect.failCause(error.failure) : f(error.success)
+}
+
 /** @internal */
 export interface Sample<out A> {
   readonly _tag: "Generated"
@@ -129,10 +149,13 @@ export function concatPulls<A>(pulls: ReadonlyArray<ShrinkPull<A>>): ShrinkPull<
     Effect.suspend(() =>
       index >= pulls.length
         ? done()
-        : Effect.catch(pulls[index], () => {
-          index++
-          return loop()
-        })
+        : Effect.catchCause(
+          pulls[index],
+          onTypedFailure(() => {
+            index++
+            return loop()
+          })
+        )
     )
   return loop()
 }
@@ -182,11 +205,11 @@ export function retain<A>(sample: Sample<A>): Retained<A> {
       return Effect.suspend(() => {
         if (history !== undefined && index < history.length) return Effect.succeed(history[index++])
         if (ended) return done()
-        return Effect.matchEffect(source, {
-          onFailure: () => {
+        return Effect.matchCauseEffect(source, {
+          onFailure: onTypedFailure(() => {
             ended = true
             return done()
-          },
+          }),
           onSuccess: (attempt) => {
             const item = attempt._tag === "Discarded" ? attempt : retain(attempt)
             history ??= []
@@ -288,11 +311,11 @@ function filterMapPull<A, B>(
     Effect.suspend(() => {
       const current = stack[stack.length - 1]
       if (current === undefined) return done()
-      return Effect.matchEffect(current, {
-        onFailure: () => {
+      return Effect.matchCauseEffect(current, {
+        onFailure: onTypedFailure(() => {
           stack.pop()
           return loop()
-        },
+        }),
         onSuccess: (attempt) => {
           if (attempt._tag === "Discarded") return Effect.succeed<Attempt<B>>(attempt)
           const sample = attempt
@@ -318,11 +341,11 @@ function filterPull<A>(source: ShrinkPull<Attempt<A>>, predicate: (value: A) =>
     Effect.suspend(() => {
       const current = stack[stack.length - 1]
       if (current === undefined) return done()
-      return Effect.matchEffect(current, {
-        onFailure: () => {
+      return Effect.matchCauseEffect(current, {
+        onFailure: onTypedFailure(() => {
           stack.pop()
           return loop()
-        },
+        }),
         onSuccess: (attempt) => {
           if (attempt._tag === "Discarded") return Effect.succeed<Attempt<A>>(attempt)
           const sample = attempt

package/src/internal/arbitrary/runner.ts

@@ -383,11 +383,11 @@ function flatMapSourcePull<A, B>(
     Effect.suspend(() => {
       const current = stack[stack.length - 1]
       if (current === undefined) return done()
-      return Effect.matchEffect(current, {
-        onFailure: () => {
+      return Effect.matchCauseEffect(current, {
+        onFailure: Model.onTypedFailure(() => {
           stack.pop()
           return loop()
-        },
+        }),
         onSuccess: (sourceAttempt) => {
           if (sourceAttempt._tag === "Discarded") return Effect.succeed<Model.Attempt<B>>(sourceAttempt)
           const sourceSample = sourceAttempt
@@ -505,14 +505,14 @@ const evaluateProperty = <A, E, R>(
 ): Effect.Effect<typeof passedProperty | PropertyFailure<E>, never, R> => {
   const output = property(value)
   if (!Effect.isEffect(output)) return Effect.succeed(output === true ? passedProperty : returnedFalse)
-  return Effect.matchEager(output, {
-    onFailure: (error): PropertyError<E> => ({ _tag: "PropertyError", error }),
-    onSuccess: (success) => success === true ? passedProperty : returnedFalse
+  return Effect.matchCauseEffectEager(output, {
+    onFailure: Model.onTypedFailure((error: E) => Effect.succeed<PropertyError<E>>({ _tag: "PropertyError", error })),
+    onSuccess: (success) => Effect.succeed(success === true ? passedProperty : returnedFalse)
   })
 }
 
 const pullNext = <A>(pull: Model.ShrinkPull<Model.Attempt<A>>): Effect.Effect<Model.Attempt<A> | undefined> =>
-  Effect.catch(pull, () => Effect.succeed(undefined))
+  Effect.catchCause(pull, Model.onTypedFailure(() => Effect.succeed(undefined)))
 
 const shrink = Effect.fnUntraced(function*<A, E, R>(
   initial: Model.Sample<A>,

package/src/internal/arbitrary/schema.ts

@@ -30,10 +30,11 @@ interface Checks {
 
 const infinity = Number.POSITIVE_INFINITY
 const finiteNumberConstraint: FilterConstraint = { number: "finite" }
-const optionMatch = { onFailure: Option.none, onSuccess: Option.some }
-
 const optionComputation = <A, E, R>(self: Effect.Effect<A, E, R>): Model.Computation<Option.Option<A>> => {
-  const result = Effect.matchEager(self, optionMatch) as Effect.Effect<Option.Option<A>>
+  const result = Effect.matchCauseEffectEager(self, {
+    onFailure: Model.onTypedFailure(() => Effect.succeedNone),
+    onSuccess: Effect.succeedSome
+  }) as Effect.Effect<Option.Option<A>>
   return effectIsExit(result) && result._tag === "Success" ? result.value : result
 }
 

package/src/internal/effect.ts

@@ -345,6 +345,8 @@ export const causePrettyError = (
     error = new globalThis.Error(
       !original ? `Unknown error: ${original}` : kind === "string" ? original as any : formatJson(original)
     )
+    const stack = `${error.name}: ${error.message}`
+    error.stack = annotations ? addStackAnnotations(stack, annotations) : stack
   }
   return error
 }
@@ -629,44 +631,46 @@ export class FiberImpl<A = any, E = any> implements Fiber.Fiber<A, E> {
     this.currentOpCount = 0
     try {
       while (true) {
-        if (this._deferredInterrupt) {
-          this._deferredInterrupt = false
-          current = failCause(this._interruptedCause!) as any
-        }
-        this.currentOpCount++
-        // Refresh the cache because a primitive can replace the fiber context.
-        const cache = this.cache
-        if (
-          !yielding &&
-          !cache.preventYield &&
-          cache.scheduler.shouldYield(this as any)
-        ) {
-          yielding = true
-          const prev = current
-          current = flatMap(yieldNow, () => prev as any) as any
-        }
-        current = cache.tracerContext
-          ? cache.tracerContext(current as any, this)
-          : (current as any)[evaluate](this)
-        if (current === Yield) {
-          const yielded = this._yielded!
-          if (ExitTypeId in yielded) {
+        try {
+          if (this._deferredInterrupt) {
             this._deferredInterrupt = false
-            this._yielded = undefined
-            return yielded
-          } else if (this._deferredInterrupt) {
-            this._yielded = undefined
-            yielded()
-            continue
+            current = failCause(this._interruptedCause!) as any
+          }
+          this.currentOpCount++
+          // Refresh the cache because a primitive can replace the fiber context.
+          const cache = this.cache
+          if (
+            !yielding &&
+            !cache.preventYield &&
+            cache.scheduler.shouldYield(this as any)
+          ) {
+            yielding = true
+            const prev = current
+            current = flatMap(yieldNow, () => prev as any) as any
           }
-          return Yield
+          current = cache.tracerContext
+            ? cache.tracerContext(current as any, this)
+            : (current as any)[evaluate](this)
+          if (current === Yield) {
+            const yielded = this._yielded!
+            if (ExitTypeId in yielded) {
+              this._deferredInterrupt = false
+              this._yielded = undefined
+              return yielded
+            } else if (this._deferredInterrupt) {
+              this._yielded = undefined
+              yielded()
+              continue
+            }
+            return Yield
+          }
+        } catch (error) {
+          if (!hasProperty(current, evaluate)) {
+            return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`)
+          }
+          current = exitDie(error) as any
         }
       }
-    } catch (error) {
-      if (!hasProperty(current, evaluate)) {
-        return exitDie(`Fiber.runLoop: Not a valid effect: ${String(current)}`)
-      }
-      return this.runLoop(exitDie(error) as any)
     } finally {
       this._running = prevRunning
       ;(globalThis as any)[currentFiberTypeId] = prevFiber
@@ -1503,6 +1507,7 @@ const succeedPayload = function(this: { readonly payload: any }, _value: unknown
 // V8 includes the property name of a stored continuation in its stack trace.
 // Other engines need an explicit frame for the stack cleaner to cut at.
 const continuationMarksStack = (() => {
+  if (getStackTraceLimit() === 0) return false
   const marker = "~effect/Effect/stackProbe"
   const probe = {
     [marker]: function stackProbe() {
@@ -3928,10 +3933,8 @@ export const scopeTag: Context.Service<Scope.Scope, Scope.Scope> = Context.Servi
 /** @internal */
 export const scopeClose = <A, E>(self: Scope.Scope, exit_: Exit.Exit<A, E>) =>
   withFiber((fiber) => {
-    const close = scopeCloseUnsafe(self, exit_)
-    if (close === undefined) return void_
     fiberEnterUninterruptibleUnsafe(fiber)
-    return close
+    return scopeCloseUnsafe(self, exit_) ?? void_
   })
 
 /** @internal */
@@ -4451,7 +4454,7 @@ export const cachedInvalidateWithTTL: {
 const infiniteTTL = constant(Infinity)
 
 interface CachedRun<A, E> {
-  fiber: FiberImpl<A, E> | undefined
+  readonly fiber: FiberImpl<A, E>
   awaiters: number
 }
 
@@ -4468,17 +4471,19 @@ const makeCachedUnsafe = <A, E, R>(
     onExitUnsafe(fiber, () => {
       // Abandon the run once every caller has left, unless it already finished.
       if (--run.awaiters > 0 || current !== run) return
-      // Detach it first so new callers start a fresh run instead of joining
-      // one that is being interrupted.
+      // Detach before interruption so new callers start a fresh run.
       current = undefined
-      return fiberInterrupt(run.fiber!)
+      return fiberInterrupt(run.fiber)
     })
-    return fiberJoin(run.fiber!)
+    return fiberJoin(run.fiber)
   }
 
   return [
     withFiber((fiber) => {
-      if (current !== undefined) return join(fiber, current)
+      if (current !== undefined) {
+        // A run joining itself is not an awaiter, so external callers can still abandon it.
+        return fiber === current.fiber ? fiberJoin(current.fiber) : join(fiber, current)
+      }
       if (
         exit !== undefined &&
         (expiresAt === Infinity || fiber.getRef(ClockRef).currentTimeMillisUnsafe() < expiresAt)
@@ -4487,10 +4492,11 @@ const makeCachedUnsafe = <A, E, R>(
       }
       exit = undefined
       const clock = fiber.getRef(ClockRef)
-      const run: CachedRun<A, E> = { fiber: undefined, awaiters: 0 }
+      const run: CachedRun<A, E> = { fiber: new FiberImpl(fiber.context), awaiters: 0 }
       current = run
-      run.fiber = forkUnsafe(
-        fiber,
+      // Join before evaluating, which may synchronously re-enter and interrupt other awaiters.
+      const joined = join(fiber, run)
+      run.fiber.evaluate(
         onExitPrimitive(self, (exit_) => {
           // An abandoned run must not overwrite or clear a replacement run.
           if (current !== run) return
@@ -4500,11 +4506,9 @@ const makeCachedUnsafe = <A, E, R>(
           const duration = ttlMillis(exit_)
           expiresAt = duration === Infinity ? Infinity : clock.currentTimeMillisUnsafe() + duration
           exit = exit_
-        }),
-        true,
-        true
+        }) as any
       )
-      return run.fiber._exit ?? join(fiber, run)
+      return run.fiber._exit ?? joined
     }),
     sync(() => {
       exit = undefined
@@ -5524,6 +5528,10 @@ export const forkUnsafe = <FA, FE, A, E, R>(
   const parentRuntime = parent as FiberImpl<FA, FE>
   const interruptible = uninterruptible === "inherit" ? parentRuntime.interruptible : !uninterruptible
   const child = new FiberImpl<A, E>(parentRuntime.context, interruptible)
+  if (!daemon) {
+    parentRuntime.children().add(child)
+    child._parent = parentRuntime
+  }
   if (immediate) {
     child.evaluate(effect as any)
   } else {
@@ -5531,10 +5539,6 @@ export const forkUnsafe = <FA, FE, A, E, R>(
     child._asyncContext = captureAsyncContext()
     parentRuntime.currentDispatcher.scheduleTask(() => child.evaluate(effect as any), 0)
   }
-  if (!daemon && !child._exit) {
-    parentRuntime.children().add(child)
-    child._parent = parentRuntime
-  }
   return child
 }
 
@@ -5711,9 +5715,9 @@ export const fiberRunIn: {
     self.interruptUnsafe(self.id)
     return self
   }
-  const key = {}
-  scopeAddFinalizerUnsafe(scope, key, () => fiberInterrupt(self))
-  self.addObserver(() => scopeRemoveFinalizerUnsafe(scope, key))
+  scopeRemoveFinalizerUnsafe(scope, self)
+  scopeAddFinalizerUnsafe(scope, self, () => fiberInterrupt(self))
+  self.addObserver(() => scopeRemoveFinalizerUnsafe(scope, self))
   return self
 })
 
@@ -6026,7 +6030,7 @@ export const makeSpanUnsafe = <XA, XE>(
       links,
       startTime: timingEnabled ? clock.currentTimeNanosUnsafe() : bigint0,
       kind: options?.kind ?? "internal",
-      root: options?.root ?? Option.isNone(parent),
+      root: options?.root ?? false,
       sampled: options?.sampled ??
         (Option.isSome(parent) && parent.value.sampled === false
           ? false

package/src/internal/schedule.ts

@@ -3,12 +3,16 @@ import type { Effect, Repeat, Retry } from "../Effect.ts"
 import { constant, constTrue, dual, identity } from "../Function.ts"
 import * as Option from "../Option.ts"
 import * as Pull from "../Pull.ts"
+import * as Result from "../Result.ts"
 import * as Schedule from "../Schedule.ts"
 import type { NoInfer } from "../Types.ts"
 import { internalCall } from "../Utils.ts"
 import * as core from "./core.ts"
 import * as effect from "./effect.ts"
 
+const findErrorOnly = <E>(cause: Cause.Cause<E>): Result.Result<E, Cause.Cause<never>> =>
+  cause.reasons.every(core.isFailReason) ? effect.findError(cause) : Result.fail(cause as Cause.Cause<never>)
+
 /** @internal */
 export const repeatOrElse: {
   <R2, A, B, E, E2, E3, R3>(
@@ -29,21 +33,22 @@ export const repeatOrElse: {
 ): Effect<B, E3, R | R2 | R3> =>
   effect.flatMap(Schedule.toStepWithMetadata(schedule), (step) => {
     let meta = Schedule.CurrentMetadata.defaultValue()
-    return effect.catch_(
-      effect.forever(
-        effect.tap(
-          effect.flatMap(effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta)), step),
-          (meta_) =>
-            effect.sync(() => {
-              meta = meta_
-            })
+    return effect.catchCauseFilter(
+      Pull.catchDone(
+        effect.forever(
+          effect.tap(
+            effect.flatMap(effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta)), step),
+            (meta_) =>
+              effect.sync(() => {
+                meta = meta_
+              })
+          ),
+          { disableYield: true }
         ),
-        { disableYield: true }
+        (out) => effect.succeed(out as B)
       ),
-      (error) =>
-        core.isDone(error)
-          ? effect.succeed(error.value as B)
-          : orElse(error as E | E2, meta.attempt === 0 ? Option.none() : Option.some(meta as any))
+      findErrorOnly,
+      (error) => orElse(error, meta.attempt === 0 ? Option.none() : Option.some(meta as any))
     )
   }))
 
@@ -66,8 +71,9 @@ export const retryOrElse: {
   effect.flatMap(Schedule.toStepWithMetadata(policy), (step) => {
     let meta = Schedule.CurrentMetadata.defaultValue()
     let lastError!: E
-    const loop: Effect<A, E1 | Cause.Done<A1>, R | R1> = effect.catch_(
+    const loop: Effect<A, E1 | Cause.Done<A1>, R | R1> = effect.catchCauseFilter(
       effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta)),
+      findErrorOnly,
       (error) => {
         lastError = error
         return effect.flatMap(step(error), (meta_) => {
@@ -198,7 +204,7 @@ export const scheduleFrom = dual<
   effect.flatMap(Schedule.toStepWithMetadata(schedule), (step) => {
     let meta = Schedule.CurrentMetadata.defaultValue()
     const selfWithMeta = effect.suspend(() => effect.provideService(self, Schedule.CurrentMetadata, meta))
-    return effect.catch_(
+    return Pull.catchDone(
       effect.flatMap(
         step(initial),
         (meta_) => {
@@ -210,10 +216,10 @@ export const scheduleFrom = dual<
             step(meta_) {
               meta = meta_
             }
-          }) as Effect<never, E, R | Env>
+          }) as Effect<never, E | Error | Cause.Done<Output>, R | Env>
         }
       ),
-      (error) => core.isDone(error) ? effect.succeed(error.value as Output) : effect.fail(error as E | Error)
+      (out) => effect.succeed(out as Output)
     )
   }))
 

package/src/internal/schema/standardSchema.ts

@@ -53,7 +53,7 @@ export function toStandardSchemaV1<S extends Schema.ConstraintDecoder<unknown>>(
       })
     })
   }
-  if ("~standard" in self) {
+  if (Object.hasOwn(self, "~standard")) {
     const out = self as any
     if ("validate" in out["~standard"]) return out
     Object.assign(out["~standard"], { validate })
@@ -109,7 +109,7 @@ export function toStandardJSONSchemaV1<S extends Schema.Constraint>(
       return toBaseStandardJSONSchemaV1(SchemaAST.toType(self.ast), options.target)
     }
   }
-  if ("~standard" in self) {
+  if (Object.hasOwn(self, "~standard")) {
     const out = self as any
     if ("jsonSchema" in out["~standard"]) return out
     Object.assign(out["~standard"], { jsonSchema })

package/src/internal/version.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export const version = "4.0.3"