effect 4.0.1 → 4.0.2

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
+          }
+          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)}`)
           }
-          return Yield
+          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
@@ -3928,10 +3932,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 */
@@ -5524,6 +5526,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 +5537,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 +5713,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 +6028,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.2"

package/src/observability/OtlpExporter.ts

@@ -26,6 +26,7 @@ import * as Num from "../Number.ts"
 import * as Option from "../Option.ts"
 import * as Schedule from "../Schedule.ts"
 import * as Scope from "../Scope.ts"
+import * as Version from "../Version.ts"
 
 const retryAfterDelay = (value: string | undefined): Effect.Effect<Duration.Duration> => {
   const seconds = Option.fromUndefinedOr(value).pipe(Option.flatMap(Num.parse))
@@ -194,12 +195,14 @@ export const make: (
     HttpClient.retryTransient({ schedule: policy, times: 3 })
   )
 
-  let headers = Headers.fromRecordUnsafe({
-    "user-agent": `effect-opentelemetry-${options.label}/0.0.0`
-  })
-  if (options.headers) {
-    headers = Headers.merge(Headers.fromInput(options.headers), headers)
-  }
+  const exporterUserAgent = `OTel-OTLP-Exporter-JavaScript-Effect-${options.label}/${Version.getCurrentVersion()}`
+  const userHeaders = Headers.fromInput(options.headers)
+  const userAgent = userHeaders["user-agent"]
+  const headers = Headers.set(
+    userHeaders,
+    "user-agent",
+    userAgent ? `${userAgent} ${exporterUserAgent}` : exporterUserAgent
+  )
 
   const request = HttpClientRequest.post(options.url, { headers })
   let buffer: Array<any> = []

package/src/observability/OtlpLogger.ts

@@ -23,6 +23,7 @@ import type * as LogLevel from "../LogLevel.ts"
 import * as Option from "../Option.ts"
 import { CurrentLogAnnotations, CurrentLogSpans } from "../References.ts"
 import type * as Scope from "../Scope.ts"
+import * as Version from "../Version.ts"
 import * as OtlpEnv from "./internal/otlpEnv.ts"
 import * as Exporter from "./OtlpExporter.ts"
 import type { AnyValue, Fixed64, KeyValue, Resource } from "./OtlpResource.ts"
@@ -64,7 +65,8 @@ export const make: (
   const serialization = yield* OtlpSerialization
   const otelResource = yield* OtlpResource.fromConfig(options.resource)
   const scope: IInstrumentationScope = {
-    name: OtlpResource.serviceNameUnsafe(otelResource)
+    name: "effect",
+    version: Version.getCurrentVersion()
   }
 
   const exporter = yield* Exporter.make({
@@ -192,32 +194,29 @@ export interface LogsData {
 
 // internal
 
+const nanosPerMilli = BigInt(1_000_000)
+
 const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   readonly excludeLogSpans: boolean
   readonly clock: Clock
 }): ILogRecord => {
-  const now = opts.clock.currentTimeNanosUnsafe()
-  const nanosString = now.toString()
-  const nowMillis = options.date.getTime()
+  const observedTime = opts.clock.currentTimeNanosUnsafe().toString()
+  const eventMillis = options.date.getTime()
+  const eventTime = (BigInt(eventMillis) * nanosPerMilli).toString()
 
-  const attributes = OtlpResource.entriesToAttributes(Object.entries(options.fiber.getRef(CurrentLogAnnotations)))
-  attributes.push({
-    key: "fiberId",
-    value: { intValue: options.fiber.id }
-  })
+  const attributes: Record<string, unknown> = { ...options.fiber.getRef(CurrentLogAnnotations) }
+  attributes["effect.fiberId"] = options.fiber.id
   if (!opts.excludeLogSpans) {
+    // Outermost spans win duplicate labels.
     for (const [label, startTime] of options.fiber.getRef(CurrentLogSpans)) {
-      attributes.push({
-        key: `logSpan.${label}`,
-        value: { stringValue: `${nowMillis - startTime}ms` }
-      })
+      attributes[`effect.log_span.${label}`] = eventMillis - startTime
     }
   }
-  if (options.cause.reasons.length > 0) {
-    attributes.push({
-      key: "log.error",
-      value: { stringValue: Cause.pretty(options.cause) }
-    })
+  const errors = Cause.prettyErrors(options.cause, { includeCauseInStack: true })
+  if (errors.length > 0) {
+    attributes["exception.type"] = errors[0].name
+    attributes["exception.message"] = errors[0].message
+    attributes["exception.stacktrace"] = errors.map((error) => error.stack).join("\n")
   }
 
   const message = Arr.ensure(options.message)
@@ -225,9 +224,9 @@ const makeLogRecord = (options: Logger.Options<unknown>, opts: {
   const logRecord: ILogRecord = {
     severityNumber: logLevelToSeverityNumber(options.logLevel),
     severityText: options.logLevel,
-    timeUnixNano: nanosString,
-    observedTimeUnixNano: nanosString,
-    attributes,
+    timeUnixNano: eventTime,
+    observedTimeUnixNano: observedTime,
+    attributes: OtlpResource.entriesToAttributes(Object.entries(attributes)),
     body: OtlpResource.unknownToAttributeValue(message.length === 1 ? message[0] : message),
     droppedAttributesCount: 0
   }