effect 3.9.2 → 3.10.1

package/src/internal/channel/channelExecutor.ts

@@ -101,247 +101,246 @@ export class ChannelExecutor<
           } else {
             if (Effect.isEffect(this._currentChannel)) {
               this._currentChannel = core.fromEffect(this._currentChannel) as core.Primitive
-            } else {
-              switch (this._currentChannel._tag) {
-                case ChannelOpCodes.OP_BRACKET_OUT: {
-                  result = this.runBracketOut(this._currentChannel)
-                  break
-                }
+            }
+            switch (this._currentChannel._tag) {
+              case ChannelOpCodes.OP_BRACKET_OUT: {
+                result = this.runBracketOut(this._currentChannel)
+                break
+              }
 
-                case ChannelOpCodes.OP_BRIDGE: {
-                  const bridgeInput = this._currentChannel.input
-
-                  // PipeTo(left, Bridge(queue, channel))
-                  // In a fiber: repeatedly run left and push its outputs to the queue
-                  // Add a finalizer to interrupt the fiber and close the executor
-                  this._currentChannel = this._currentChannel.channel as core.Primitive
-
-                  if (this._input !== undefined) {
-                    const inputExecutor = this._input
-                    this._input = undefined
-
-                    const drainer = (): Effect.Effect<unknown, never, Env> =>
-                      Effect.flatMap(bridgeInput.awaitRead(), () =>
-                        Effect.suspend(() => {
-                          const state = inputExecutor.run() as ChannelState.Primitive
-                          switch (state._tag) {
-                            case ChannelStateOpCodes.OP_DONE: {
-                              return Exit.match(inputExecutor.getDone(), {
-                                onFailure: (cause) => bridgeInput.error(cause),
-                                onSuccess: (value) => bridgeInput.done(value)
-                              })
-                            }
-                            case ChannelStateOpCodes.OP_EMIT: {
-                              return Effect.flatMap(
-                                bridgeInput.emit(inputExecutor.getEmit()),
-                                () => drainer()
-                              )
-                            }
-                            case ChannelStateOpCodes.OP_FROM_EFFECT: {
-                              return Effect.matchCauseEffect(state.effect, {
-                                onFailure: (cause) => bridgeInput.error(cause),
-                                onSuccess: () => drainer()
-                              })
-                            }
-                            case ChannelStateOpCodes.OP_READ: {
-                              return readUpstream(
-                                state,
-                                () => drainer(),
-                                (cause) => bridgeInput.error(cause)
-                              )
-                            }
+              case ChannelOpCodes.OP_BRIDGE: {
+                const bridgeInput = this._currentChannel.input
+
+                // PipeTo(left, Bridge(queue, channel))
+                // In a fiber: repeatedly run left and push its outputs to the queue
+                // Add a finalizer to interrupt the fiber and close the executor
+                this._currentChannel = this._currentChannel.channel as core.Primitive
+
+                if (this._input !== undefined) {
+                  const inputExecutor = this._input
+                  this._input = undefined
+
+                  const drainer = (): Effect.Effect<unknown, never, Env> =>
+                    Effect.flatMap(bridgeInput.awaitRead(), () =>
+                      Effect.suspend(() => {
+                        const state = inputExecutor.run() as ChannelState.Primitive
+                        switch (state._tag) {
+                          case ChannelStateOpCodes.OP_DONE: {
+                            return Exit.match(inputExecutor.getDone(), {
+                              onFailure: (cause) => bridgeInput.error(cause),
+                              onSuccess: (value) => bridgeInput.done(value)
+                            })
+                          }
+                          case ChannelStateOpCodes.OP_EMIT: {
+                            return Effect.flatMap(
+                              bridgeInput.emit(inputExecutor.getEmit()),
+                              () => drainer()
+                            )
+                          }
+                          case ChannelStateOpCodes.OP_FROM_EFFECT: {
+                            return Effect.matchCauseEffect(state.effect, {
+                              onFailure: (cause) => bridgeInput.error(cause),
+                              onSuccess: () => drainer()
+                            })
                           }
-                        })) as Effect.Effect<unknown, never, Env>
-
-                    result = ChannelState.fromEffect(
-                      Effect.flatMap(
-                        Effect.forkDaemon(drainer()),
-                        (fiber) =>
-                          Effect.sync(() =>
-                            this.addFinalizer((exit) =>
-                              Effect.flatMap(Fiber.interrupt(fiber), () =>
-                                Effect.suspend(() => {
-                                  const effect = this.restorePipe(exit, inputExecutor)
-                                  return effect !== undefined ? effect : Effect.void
-                                }))
+                          case ChannelStateOpCodes.OP_READ: {
+                            return readUpstream(
+                              state,
+                              () => drainer(),
+                              (cause) => bridgeInput.error(cause)
                             )
+                          }
+                        }
+                      })) as Effect.Effect<unknown, never, Env>
+
+                  result = ChannelState.fromEffect(
+                    Effect.flatMap(
+                      Effect.forkDaemon(Effect.interruptible(drainer())),
+                      (fiber) =>
+                        Effect.sync(() =>
+                          this.addFinalizer((exit) =>
+                            Effect.flatMap(Fiber.interrupt(fiber), () =>
+                              Effect.suspend(() => {
+                                const effect = this.restorePipe(exit, inputExecutor)
+                                return effect !== undefined ? effect : Effect.void
+                              }))
                           )
-                      )
+                        )
                     )
-                  }
-
-                  break
-                }
-
-                case ChannelOpCodes.OP_CONCAT_ALL: {
-                  const executor: ErasedExecutor<Env> = new ChannelExecutor(
-                    this._currentChannel.value() as Channel.Channel<
-                      never,
-                      unknown,
-                      never,
-                      unknown,
-                      never,
-                      unknown,
-                      Env
-                    >,
-                    this._providedEnv,
-                    (effect) =>
-                      Effect.sync(() => {
-                        const prevLastClose = this._closeLastSubstream === undefined
-                          ? Effect.void
-                          : this._closeLastSubstream
-                        this._closeLastSubstream = pipe(prevLastClose, Effect.zipRight(effect))
-                      })
-                  )
-                  executor._input = this._input
-
-                  const channel = this._currentChannel
-                  this._activeSubexecutor = new Subexecutor.PullFromUpstream(
-                    executor,
-                    (value) => channel.k(value),
-                    undefined,
-                    [],
-                    (x, y) => channel.combineInners(x, y),
-                    (x, y) => channel.combineAll(x, y),
-                    (request) => channel.onPull(request),
-                    (value) => channel.onEmit(value)
                   )
+                }
 
-                  this._closeLastSubstream = undefined
-                  this._currentChannel = undefined
+                break
+              }
 
-                  break
-                }
+              case ChannelOpCodes.OP_CONCAT_ALL: {
+                const executor: ErasedExecutor<Env> = new ChannelExecutor(
+                  this._currentChannel.value() as Channel.Channel<
+                    never,
+                    unknown,
+                    never,
+                    unknown,
+                    never,
+                    unknown,
+                    Env
+                  >,
+                  this._providedEnv,
+                  (effect) =>
+                    Effect.sync(() => {
+                      const prevLastClose = this._closeLastSubstream === undefined
+                        ? Effect.void
+                        : this._closeLastSubstream
+                      this._closeLastSubstream = pipe(prevLastClose, Effect.zipRight(effect))
+                    })
+                )
+                executor._input = this._input
+
+                const channel = this._currentChannel
+                this._activeSubexecutor = new Subexecutor.PullFromUpstream(
+                  executor,
+                  (value) => channel.k(value),
+                  undefined,
+                  [],
+                  (x, y) => channel.combineInners(x, y),
+                  (x, y) => channel.combineAll(x, y),
+                  (request) => channel.onPull(request),
+                  (value) => channel.onEmit(value)
+                )
+
+                this._closeLastSubstream = undefined
+                this._currentChannel = undefined
+
+                break
+              }
 
-                case ChannelOpCodes.OP_EMIT: {
-                  this._emitted = this._currentChannel.out
-                  this._currentChannel = (this._activeSubexecutor !== undefined ?
-                    undefined :
-                    core.void) as core.Primitive | undefined
-                  result = ChannelState.Emit()
-                  break
-                }
+              case ChannelOpCodes.OP_EMIT: {
+                this._emitted = this._currentChannel.out
+                this._currentChannel = (this._activeSubexecutor !== undefined ?
+                  undefined :
+                  core.void) as core.Primitive | undefined
+                result = ChannelState.Emit()
+                break
+              }
 
-                case ChannelOpCodes.OP_ENSURING: {
-                  this.runEnsuring(this._currentChannel)
-                  break
-                }
+              case ChannelOpCodes.OP_ENSURING: {
+                this.runEnsuring(this._currentChannel)
+                break
+              }
 
-                case ChannelOpCodes.OP_FAIL: {
-                  result = this.doneHalt(this._currentChannel.error())
-                  break
-                }
+              case ChannelOpCodes.OP_FAIL: {
+                result = this.doneHalt(this._currentChannel.error())
+                break
+              }
 
-                case ChannelOpCodes.OP_FOLD: {
-                  this._doneStack.push(this._currentChannel.k as ErasedContinuation<Env>)
-                  this._currentChannel = this._currentChannel.channel as core.Primitive
-                  break
-                }
+              case ChannelOpCodes.OP_FOLD: {
+                this._doneStack.push(this._currentChannel.k as ErasedContinuation<Env>)
+                this._currentChannel = this._currentChannel.channel as core.Primitive
+                break
+              }
 
-                case ChannelOpCodes.OP_FROM_EFFECT: {
-                  const effect = this._providedEnv === undefined ?
-                    this._currentChannel.effect() :
-                    pipe(
-                      this._currentChannel.effect(),
-                      Effect.provide(this._providedEnv)
-                    )
+              case ChannelOpCodes.OP_FROM_EFFECT: {
+                const effect = this._providedEnv === undefined ?
+                  this._currentChannel.effect() :
+                  pipe(
+                    this._currentChannel.effect(),
+                    Effect.provide(this._providedEnv)
+                  )
 
-                  result = ChannelState.fromEffect(
-                    Effect.matchCauseEffect(effect, {
-                      onFailure: (cause) => {
-                        const state = this.doneHalt(cause)
-                        return state !== undefined && ChannelState.isFromEffect(state) ?
-                          state.effect :
-                          Effect.void
-                      },
-                      onSuccess: (value) => {
-                        const state = this.doneSucceed(value)
-                        return state !== undefined && ChannelState.isFromEffect(state) ?
-                          state.effect :
-                          Effect.void
-                      }
-                    })
-                  ) as ChannelState.ChannelState<unknown, Env> | undefined
+                result = ChannelState.fromEffect(
+                  Effect.matchCauseEffect(effect, {
+                    onFailure: (cause) => {
+                      const state = this.doneHalt(cause)
+                      return state !== undefined && ChannelState.isFromEffect(state) ?
+                        state.effect :
+                        Effect.void
+                    },
+                    onSuccess: (value) => {
+                      const state = this.doneSucceed(value)
+                      return state !== undefined && ChannelState.isFromEffect(state) ?
+                        state.effect :
+                        Effect.void
+                    }
+                  })
+                ) as ChannelState.ChannelState<unknown, Env> | undefined
 
-                  break
-                }
+                break
+              }
 
-                case ChannelOpCodes.OP_PIPE_TO: {
-                  const previousInput = this._input
+              case ChannelOpCodes.OP_PIPE_TO: {
+                const previousInput = this._input
 
-                  const leftExec: ErasedExecutor<Env> = new ChannelExecutor(
-                    this._currentChannel.left() as Channel.Channel<never, unknown, never, unknown, never, unknown, Env>,
-                    this._providedEnv,
-                    (effect) => this._executeCloseLastSubstream(effect)
-                  )
-                  leftExec._input = previousInput
-                  this._input = leftExec
+                const leftExec: ErasedExecutor<Env> = new ChannelExecutor(
+                  this._currentChannel.left() as Channel.Channel<never, unknown, never, unknown, never, unknown, Env>,
+                  this._providedEnv,
+                  (effect) => this._executeCloseLastSubstream(effect)
+                )
+                leftExec._input = previousInput
+                this._input = leftExec
 
-                  this.addFinalizer((exit) => {
-                    const effect = this.restorePipe(exit, previousInput)
-                    return effect !== undefined ? effect : Effect.void
-                  })
+                this.addFinalizer((exit) => {
+                  const effect = this.restorePipe(exit, previousInput)
+                  return effect !== undefined ? effect : Effect.void
+                })
 
-                  this._currentChannel = this._currentChannel.right() as core.Primitive
+                this._currentChannel = this._currentChannel.right() as core.Primitive
 
-                  break
-                }
+                break
+              }
 
-                case ChannelOpCodes.OP_PROVIDE: {
-                  const previousEnv = this._providedEnv
-                  this._providedEnv = this._currentChannel.context()
-                  this._currentChannel = this._currentChannel.inner as core.Primitive
-                  this.addFinalizer(() =>
-                    Effect.sync(() => {
-                      this._providedEnv = previousEnv
-                    })
-                  )
-                  break
-                }
+              case ChannelOpCodes.OP_PROVIDE: {
+                const previousEnv = this._providedEnv
+                this._providedEnv = this._currentChannel.context()
+                this._currentChannel = this._currentChannel.inner as core.Primitive
+                this.addFinalizer(() =>
+                  Effect.sync(() => {
+                    this._providedEnv = previousEnv
+                  })
+                )
+                break
+              }
 
-                case ChannelOpCodes.OP_READ: {
-                  const read = this._currentChannel
-                  result = ChannelState.Read(
-                    this._input!,
-                    identity,
-                    (emitted) => {
-                      try {
-                        this._currentChannel = read.more(emitted) as core.Primitive
-                      } catch (error) {
-                        this._currentChannel = read.done.onExit(Exit.die(error)) as core.Primitive
-                      }
-                      return undefined
-                    },
-                    (exit) => {
-                      const onExit = (exit: Exit.Exit<unknown, unknown>): core.Primitive => {
-                        return read.done.onExit(exit) as core.Primitive
-                      }
-                      this._currentChannel = onExit(exit)
-                      return undefined
+              case ChannelOpCodes.OP_READ: {
+                const read = this._currentChannel
+                result = ChannelState.Read(
+                  this._input!,
+                  identity,
+                  (emitted) => {
+                    try {
+                      this._currentChannel = read.more(emitted) as core.Primitive
+                    } catch (error) {
+                      this._currentChannel = read.done.onExit(Exit.die(error)) as core.Primitive
                     }
-                  )
-                  break
-                }
+                    return undefined
+                  },
+                  (exit) => {
+                    const onExit = (exit: Exit.Exit<unknown, unknown>): core.Primitive => {
+                      return read.done.onExit(exit) as core.Primitive
+                    }
+                    this._currentChannel = onExit(exit)
+                    return undefined
+                  }
+                )
+                break
+              }
 
-                case ChannelOpCodes.OP_SUCCEED: {
-                  result = this.doneSucceed(this._currentChannel.evaluate())
-                  break
-                }
+              case ChannelOpCodes.OP_SUCCEED: {
+                result = this.doneSucceed(this._currentChannel.evaluate())
+                break
+              }
 
-                case ChannelOpCodes.OP_SUCCEED_NOW: {
-                  result = this.doneSucceed(this._currentChannel.terminal)
-                  break
-                }
+              case ChannelOpCodes.OP_SUCCEED_NOW: {
+                result = this.doneSucceed(this._currentChannel.terminal)
+                break
+              }
 
-                case ChannelOpCodes.OP_SUSPEND: {
-                  this._currentChannel = this._currentChannel.channel() as core.Primitive
-                  break
-                }
+              case ChannelOpCodes.OP_SUSPEND: {
+                this._currentChannel = this._currentChannel.channel() as core.Primitive
+                break
+              }
 
-                default: {
-                  // @ts-expect-error
-                  this._currentChannel._tag
-                }
+              default: {
+                // @ts-expect-error
+                this._currentChannel._tag
               }
             }
           }

package/src/internal/core-effect.ts

@@ -85,7 +85,7 @@ export const try_: {
     readonly try: LazyArg<A>
     readonly catch: (error: unknown) => E
   }): Effect.Effect<A, E>
-  <A>(evaluate: LazyArg<A>): Effect.Effect<A, Cause.UnknownException>
+  <A>(thunk: LazyArg<A>): Effect.Effect<A, Cause.UnknownException>
 } = <A, E>(
   arg: LazyArg<A> | {
     readonly try: LazyArg<A>
@@ -1656,7 +1656,7 @@ export const tryPromise: {
       readonly catch: (error: unknown) => E
     }
   ): Effect.Effect<A, E>
-  <A>(try_: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
+  <A>(evaluate: (signal: AbortSignal) => PromiseLike<A>): Effect.Effect<A, Cause.UnknownException>
 } = <A, E>(
   arg: ((signal: AbortSignal) => PromiseLike<A>) | {
     readonly try: (signal: AbortSignal) => PromiseLike<A>

package/src/internal/core.ts

@@ -521,13 +521,13 @@ export const unsafeAsync = <A, E = never, R = never>(
 
 /* @internal */
 export const async = <A, E = never, R = never>(
-  register: (
+  resume: (
     callback: (_: Effect.Effect<A, E, R>) => void,
     signal: AbortSignal
   ) => void | Effect.Effect<void, never, R>,
   blockingOn: FiberId.FiberId = FiberId.none
 ): Effect.Effect<A, E, R> => {
-  return custom(register, function() {
+  return custom(resume, function() {
     let backingResume: ((_: Effect.Effect<A, E, R>) => void) | undefined = undefined
     let pendingEffect: Effect.Effect<A, E, R> | undefined = undefined
     function proxyResume(effect: Effect.Effect<A, E, R>) {
@@ -1216,9 +1216,9 @@ export const suspend = <A, E, R>(effect: LazyArg<Effect.Effect<A, E, R>>): Effec
   flatMap(sync(effect), identity)
 
 /* @internal */
-export const sync = <A>(evaluate: LazyArg<A>): Effect.Effect<A> => {
+export const sync = <A>(thunk: LazyArg<A>): Effect.Effect<A> => {
   const effect = new EffectPrimitive(OpCodes.OP_SYNC) as any
-  effect.effect_instruction_i0 = evaluate
+  effect.effect_instruction_i0 = thunk
   return effect
 }
 

package/src/internal/fiberRuntime.ts

@@ -827,18 +827,20 @@ export class FiberRuntime<in out A, in out E = never> extends Effectable.Class<A
     if (HashSet.size(loggers) > 0) {
       const clockService = Context.get(this.getFiberRef(defaultServices.currentServices), clock.clockTag)
       const date = new Date(clockService.unsafeCurrentTimeMillis())
-      for (const logger of loggers) {
-        logger.log({
-          fiberId: this.id(),
-          logLevel,
-          message,
-          cause,
-          context: contextMap,
-          spans,
-          annotations,
-          date
-        })
-      }
+      Inspectable.withRedactableContext(contextMap, () => {
+        for (const logger of loggers) {
+          logger.log({
+            fiberId: this.id(),
+            logLevel,
+            message,
+            cause,
+            context: contextMap,
+            spans,
+            annotations,
+            date
+          })
+        }
+      })
     }
   }
 

package/src/internal/logger.ts

@@ -341,7 +341,7 @@ export const structuredMessage = (u: unknown): unknown => {
       return String(u)
     }
     default: {
-      return u
+      return Inspectable.toJSON(u)
     }
   }
 }
@@ -488,13 +488,13 @@ const prettyLoggerTty = (options: {
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
-          log(message[messageIndex])
+          log(Inspectable.redact(message[messageIndex]))
         }
       }
 
       if (HashMap.size(annotations) > 0) {
         for (const [key, value] of annotations) {
-          log(color(`${key}:`, colors.bold, colors.white), value)
+          log(color(`${key}:`, colors.bold, colors.white), Inspectable.redact(value))
         }
       }
 
@@ -553,16 +553,17 @@ const prettyLoggerBrowser = (options: {
 
       if (messageIndex < message.length) {
         for (; messageIndex < message.length; messageIndex++) {
-          console.log(message[messageIndex])
+          console.log(Inspectable.redact(message[messageIndex]))
         }
       }
 
       if (HashMap.size(annotations) > 0) {
         for (const [key, value] of annotations) {
+          const redacted = Inspectable.redact(value)
           if (options.colors) {
-            console.log(`%c${key}:`, "color:gray", value)
+            console.log(`%c${key}:`, "color:gray", redacted)
           } else {
-            console.log(`${key}:`, value)
+            console.log(`${key}:`, redacted)
           }
         }
       }

package/src/internal/redacted.ts

@@ -1,3 +1,4 @@
+import { NodeInspectSymbol } from "effect/Inspectable"
 import * as Equal from "../Equal.js"
 import { pipe } from "../Function.js"
 import { globalValue } from "../GlobalValue.js"
@@ -34,6 +35,9 @@ export const proto = {
   toJSON() {
     return "<redacted>"
   },
+  [NodeInspectSymbol]() {
+    return "<redacted>"
+  },
   [Hash.symbol]<T>(this: Redacted.Redacted<T>): number {
     return pipe(
       Hash.hash(RedactedSymbolKey),