@typed/fx 0.0.3 → 0.0.4

package/src/Fx/Instruction.ts

@@ -1,4 +1,4 @@
-import { Either } from 'hkt-ts/Either'
+import { Either, Left, Right } from 'hkt-ts/Either'
 import { Maybe } from 'hkt-ts/Maybe'
 import { Lazy, flow } from 'hkt-ts/function'
 import { NonNegativeInteger } from 'hkt-ts/number'
@@ -9,6 +9,7 @@ import { Cause } from '@/Cause/Cause.js'
 import type { Env } from '@/Env/Env.js'
 import type { Live } from '@/Fiber/Fiber.js'
 import type { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
 import type { FiberRef } from '@/FiberRef/FiberRef.js'
 import type { Future } from '@/Future/index.js'
 import type { Layer } from '@/Layer/Layer.js'
@@ -16,28 +17,29 @@ import { Service } from '@/Service/Service.js'
 import { Trace } from '@/Trace/Trace.js'
 
 export type Instruction<R, E, A> =
-  | Access<R, R, E, A>
   | AddTrace<R, E, A>
-  | BothFx<R, E, any, R, E, any>
+  | BothFx<R, E, A>
   | DeleteFiberRef<R, E, any, A>
-  | EitherFx<R, E, any, R, E, any>
+  | EitherFx<R, E, A>
   | FiberRefLocally<any, any, any, R, E, A>
   | FlatMap<R, E, any, R, E, A>
-  | Fork<R, any, A>
+  | Fork<R, E, A>
   | FromCause<E>
   | FromLazy<A>
+  | GetEnv<R, E, A>
   | GetFiberContext
   | GetFiberRef<R, E, A>
   | GetInterruptStatus
   | GetTrace
   | LazyFx<R, E, A>
   | MapFx<R, E, any, A>
-  | Match<R, E, any, R, E, A, R, E, A>
+  | Match<R, any, any, R, E, A, R, E, A>
   | ModifyFiberRef<R, E, any, A>
   | Now<A>
   | Provide<any, E, A>
-  | ProvideService<R, E, A, any>
+  | Provide<never, E, A>
   | ProvideLayer<R, E, A, R, E, any>
+  | ProvideService<R, E, A, any>
   | SetConcurrencyLevel<R, E, A>
   | SetInterruptStatus<R, E, A>
   | Wait<R, E, A>
@@ -48,7 +50,7 @@ export type AnyInstruction =
   | Instruction<never, any, any>
   | Instruction<any, never, any>
 
-export abstract class Instr<R, E, A> {
+export abstract class Instr<out R, out E, out A> {
   readonly _R!: () => R
   readonly _E!: () => E
   readonly _A!: () => A
@@ -59,12 +61,12 @@ export abstract class Instr<R, E, A> {
     this.instr = this
   }
 
-  *[Symbol.iterator](): Generator<this, A, A> {
+  *[Symbol.iterator](): Generator<this, A, any> {
     return yield this
   }
 }
 
-export class Now<A> extends Instr<never, never, A> {
+export class Now<out A> extends Instr<never, never, A> {
   readonly tag = 'Now'
   constructor(readonly value: A, readonly __trace?: string) {
     super(__trace)
@@ -75,7 +77,7 @@ export class Now<A> extends Instr<never, never, A> {
   }
 }
 
-export class FromLazy<A> extends Instr<never, never, A> {
+export class FromLazy<out A> extends Instr<never, never, A> {
   readonly tag = 'FromLazy'
   constructor(readonly f: Lazy<A>, readonly __trace?: string) {
     super(__trace)
@@ -86,7 +88,7 @@ export class FromLazy<A> extends Instr<never, never, A> {
   }
 }
 
-export class FromCause<E> extends Instr<never, E, never> {
+export class FromCause<out E> extends Instr<never, E, never> {
   readonly tag = 'FromCause'
   constructor(readonly cause: Cause<E>, readonly __trace?: string) {
     super(__trace)
@@ -97,7 +99,7 @@ export class FromCause<E> extends Instr<never, E, never> {
   }
 }
 
-export class MapFx<R, E, A, B> extends Instr<R, E, B> {
+export class MapFx<out R, out E, in out A, out B> extends Instr<R, E, B> {
   readonly tag = 'Map'
 
   constructor(readonly fx: Fx<R, E, A>, readonly f: (a: A) => B, readonly __trace?: string) {
@@ -107,19 +109,30 @@ export class MapFx<R, E, A, B> extends Instr<R, E, B> {
   static make<R, E, A, B>(fx: Fx<R, E, A>, f: (a: A) => B, __trace?: string): Fx<R, E, B> {
     const prev = fx.instr
 
+    // Eagerly evaluate the function to runtime cost. Stack unsafe.
     if (prev.tag === 'Now') {
-      return new Now(f(prev.value), __trace) as Fx<R, E, B>
+      return Now.make(f(prev.value), __trace)
+    }
+
+    // Map cannot process failures
+    if (prev.tag === 'FromCause') {
+      return prev
     }
 
+    // Fuse together multiple maps.
     if (prev.tag === 'Map') {
-      return new MapFx(prev.fx as Fx<any, any, any>, flow(prev.f, f), __trace)
+      return MapFx.make(prev.fx, flow(prev.f, f), __trace)
     }
 
     return new MapFx(fx, f, __trace)
   }
 }
 
-export class FlatMap<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, B> {
+export class FlatMap<out R, out E, in out A, out R2, out E2, out B> extends Instr<
+  R | R2,
+  E | E2,
+  B
+> {
   readonly tag = 'FlatMap'
 
   constructor(
@@ -137,23 +150,31 @@ export class FlatMap<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, B> {
   ): Fx<R | R2, E | E2, B> {
     const prev = fx.instr
 
-    if (prev.tag === 'Now') {
-      return f(prev.value) as Fx<R | R2, E | E2, B>
+    // Flatmap cannot process failures
+    if (prev.tag === 'FromCause') {
+      return prev
     }
 
+    // Fuse together Map + FlatMap into a single FlatMap.
     if (prev.tag === 'Map') {
-      return new FlatMap(prev.fx as Fx<any, any, any>, flow(prev.f, f), __trace) as Fx<
-        R | R2,
-        E | E2,
-        B
-      >
+      return FlatMap.make(prev.fx, flow(prev.f, f), __trace)
     }
 
-    return new FlatMap(fx, f, __trace) as Fx<R | R2, E | E2, B>
+    return new FlatMap(fx, f, __trace)
   }
 }
 
-export class Match<R, E, A, R2, E2, B, R3, E3, C> extends Instr<R | R2 | R3, E2 | E3, B | C> {
+export class Match<
+  out R,
+  in out E,
+  in out A,
+  out R2,
+  out E2,
+  out B,
+  out R3,
+  out E3,
+  out C,
+> extends Instr<R | R2 | R3, E2 | E3, B | C> {
   readonly tag = 'Match'
 
   constructor(
@@ -173,35 +194,24 @@ export class Match<R, E, A, R2, E2, B, R3, E3, C> extends Instr<R | R2 | R3, E2
   ): Fx<R | R2 | R3, E2 | E3, B | C> {
     const prev = fx.instr
 
-    if (prev.tag === 'Now') {
-      return onRight(prev.value) as Fx<R | R2 | R3, E2 | E3, B | C>
-    }
-
-    if (prev.tag === 'FromCause') {
-      return onLeft(prev.cause) as Fx<R | R2 | R3, E2 | E3, B | C>
-    }
-
+    // Fuse together Map + Match
     if (prev.tag === 'Map') {
-      return new Match(prev.fx as Fx<any, any, any>, onLeft, flow(prev.f, onRight), __trace) as any
+      return Match.make(prev.fx, onLeft, flow(prev.f, onRight), __trace)
     }
 
-    return new Match(fx, onLeft, onRight, __trace) as any
+    return new Match(fx, onLeft, onRight, __trace)
   }
 }
 
-export class Access<R, R2, E, A> extends Instr<R | R2, E, A> {
-  readonly tag = 'Access'
+export class GetEnv<out R, out E, out A> extends Instr<R, E, A> {
+  readonly tag = 'GetEnv'
 
-  constructor(readonly f: (r: Env<R>) => Fx<R2, E, A>, readonly __trace?: string) {
-    super(__trace)
-  }
-
-  static make<R, R2, E, A>(f: (r: Env<R>) => Fx<R2, E, A>, __trace?: string): Fx<R | R2, E, A> {
-    return new Access(f, __trace) as Fx<R | R2, E, A>
+  static make<R>(__trace?: string): Fx<R, never, Env<R>> {
+    return new GetEnv<R, never, Env<R>>(__trace)
   }
 }
 
-export class Provide<R, E, A> extends Instr<never, E, A> {
+export class Provide<out R, out E, out A> extends Instr<never, E, A> {
   readonly tag = 'Provide'
 
   constructor(readonly fx: Fx<R, E, A>, readonly env: Env<R>, readonly __trace?: string) {
@@ -274,7 +284,7 @@ export class LazyFx<R, E, A> extends Instr<R, E, A> {
 export class Wait<R, E, A> extends Instr<R, E, A> {
   readonly tag = 'Wait'
 
-  constructor(readonly future: Future<R, E, A>, readonly __trace?: string) {
+  constructor(readonly future: Future<any, any, any>, readonly __trace?: string) {
     super(__trace)
   }
 
@@ -313,10 +323,11 @@ export class SetInterruptStatus<R, E, A> extends Instr<R, E, A> {
   }
 }
 
-export class GetFiberContext extends Instr<never, never, FiberContext> {
+export class GetFiberContext extends Instr<never, never, FiberContext<FiberId.Live>> {
   readonly tag = 'GetFiberContext'
 
-  static make = (__trace?: string): Fx<never, never, FiberContext> => new GetFiberContext(__trace)
+  static make = (__trace?: string): Fx<never, never, FiberContext<FiberId.Live>> =>
+    new GetFiberContext(__trace)
 }
 
 export class GetInterruptStatus extends Instr<never, never, boolean> {
@@ -348,7 +359,7 @@ export class SetConcurrencyLevel<R, E, A> extends Instr<R, E, A> {
 export class GetFiberRef<R, E, A> extends Instr<R, E, A> {
   readonly tag = 'GetFiberRef'
 
-  constructor(readonly fiberRef: FiberRef<R, E, A>, __trace?: string) {
+  constructor(readonly fiberRef: FiberRef<any, any, any>, __trace?: string) {
     super(__trace)
   }
 
@@ -411,28 +422,32 @@ export class FiberRefLocally<R, E, A, R2, E2, B> extends Instr<R2, E2, B> {
   }
 }
 
-export class Fork<R, E, A> extends Instr<R, never, Live<E, A>> {
+export class Fork<R, E, A> extends Instr<R, E, A> {
   readonly tag = 'Fork'
 
-  constructor(readonly fx: Fx<R, E, A>, readonly context: FiberContext, readonly __trace?: string) {
+  constructor(
+    readonly fx: Fx<any, any, any>,
+    readonly context: FiberContext<FiberId.Live>,
+    readonly __trace?: string,
+  ) {
     super(__trace)
   }
 
   static make<R, E, A>(
     fx: Fx<R, E, A>,
-    context: FiberContext,
+    context: FiberContext<FiberId.Live>,
     __trace?: string,
   ): Fx<R, never, Live<E, A>> {
-    return new Fork(fx, context, __trace) as any
+    return new Fork(fx, context, __trace)
   }
 }
 
-export class BothFx<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, readonly [A, B]> {
+export class BothFx<R, E, A> extends Instr<R, E, A> {
   readonly tag = 'Both'
 
   constructor(
-    readonly first: Fx<R, E, A>,
-    readonly second: Fx<R2, E2, B>,
+    readonly first: Fx<any, any, any>,
+    readonly second: Fx<any, any, any>,
     readonly __trace?: string,
   ) {
     super(__trace)
@@ -443,16 +458,24 @@ export class BothFx<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, readonly [
     second: Fx<R2, E2, B>,
     __trace?: string,
   ): Fx<R | R2, E | E2, readonly [A, B]> {
-    return new BothFx(first, second, __trace) as Fx<R | R2, E | E2, readonly [A, B]>
+    // Any Failures cannot be combined into a tuple of success values
+    if (first.instr.tag === 'FromCause') {
+      return first.instr
+    }
+    if (second.instr.tag === 'FromCause') {
+      return second.instr
+    }
+
+    return new BothFx(first, second, __trace)
   }
 }
 
-export class EitherFx<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, Either<A, B>> {
+export class EitherFx<R, E, A> extends Instr<R, E, A> {
   readonly tag = 'Either'
 
   constructor(
-    readonly first: Fx<R, E, A>,
-    readonly second: Fx<R2, E2, B>,
+    readonly first: Fx<any, any, any>,
+    readonly second: Fx<any, any, any>,
     readonly __trace?: string,
   ) {
     super(__trace)
@@ -463,6 +486,26 @@ export class EitherFx<R, E, A, R2, E2, B> extends Instr<R | R2, E | E2, Either<A
     second: Fx<R2, E2, B>,
     __trace?: string,
   ): Fx<R | R2, E | E2, Either<A, B>> {
-    return new EitherFx(first, second, __trace) as any
+    const fi = first.instr
+
+    if (fi.tag === 'Now') {
+      return Now.make(Left(fi.value), __trace)
+    }
+
+    const si = second.instr
+
+    if (si.tag === 'Now') {
+      return Now.make(Right(si.value), __trace)
+    }
+
+    if (fi.tag === 'FromCause') {
+      return fi
+    }
+
+    if (si.tag === 'FromCause') {
+      return si
+    }
+
+    return new EitherFx(first, second, __trace)
   }
 }

package/src/Fx/fromLayer.ts

@@ -0,0 +1,8 @@
+import * as Fx from './Fx.js'
+
+import { Layer } from '@/Layer/Layer.js'
+import { Scope } from '@/Scope/Scope.js'
+
+export function fromLayer<R, E, A>(layer: Layer<R, E, A>): Fx.Fx<R | Scope, E, A> {
+  return Fx.flatMap(layer.build)(Fx.ask(Scope))
+}

package/src/Fx/index.ts

@@ -1,3 +1,4 @@
+export * from './fromLayer.js'
 export * from './Fx.js'
 export * from './join.js'
 export * from './logging.js'

package/src/Fx/join.ts

@@ -1,17 +1,30 @@
-import { Either } from 'hkt-ts'
+import { pipe } from 'hkt-ts'
 
-import { Fx, fromExit } from './Fx.js'
+import * as Fx from './Fx.js'
 
-// eslint-disable-next-line import/no-cycle
 import * as Fiber from '@/Fiber/Fiber.js'
+import { FiberContext } from '@/FiberContext/FiberContext.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { Scope } from '@/Scope/Scope.js'
 
 export const join = <E, A>(fiber: Fiber.Fiber<E, A>) =>
-  Fx(function* () {
-    const exit = yield* fiber.exit
+  pipe(
+    fiber.exit,
+    Fx.flatMap((exit) =>
+      pipe(
+        Fiber.inheritFiberRefs(fiber),
+        Fx.flatMap(() => Fx.fromExit(exit)),
+      ),
+    ),
+  )
 
-    if (Either.isRight(exit)) {
-      yield* Fiber.inheritFiberRefs(fiber)
-    }
+export const forkJoinInContext = <R, E, A>(
+  fx: Fx.Fx<R, E, A>,
+  context: FiberContext<FiberId.Live>,
+): Fx.Fx<R, E, A> => pipe(fx, Fx.forkInContext(context), Fx.flatMap(join))
 
-    return yield* fromExit(exit)
-  })
+export const forkJoinIn = <R, E, A>(fx: Fx.Fx<R, E, A>, scope: Scope): Fx.Fx<R, E, A> =>
+  pipe(fx, Fx.forkIn(scope), Fx.flatMap(join))
+
+export const forkJoin = <R, E, A>(fx: Fx.Fx<R, E, A>): Fx.Fx<R, E, A> =>
+  pipe(fx, Fx.fork, Fx.flatMap(join))

package/src/Fx/logging.ts

@@ -2,10 +2,11 @@ import { pipe } from 'hkt-ts'
 
 import * as Fx from './Fx.js'
 
-import { CurrentLogAnnotations, CurrentLogSpans } from '@/FiberRef/FiberRef.js'
+import { CurrentLogAnnotations, CurrentLogSpans } from '@/FiberRef/builtins.js'
 import { LogAnnotation } from '@/Logger/LogAnnotation.js'
 import { LogLevel } from '@/Logger/LogLevel.js'
 import { LogSpan } from '@/Logger/LogSpan.js'
+import { EmptyTrace, Trace } from '@/Trace/Trace.js'
 
 const makeLogWithLevel = (level: LogLevel) => (msg: string, __trace?: string) =>
   pipe(
@@ -13,14 +14,16 @@ const makeLogWithLevel = (level: LogLevel) => (msg: string, __trace?: string) =>
     Fx.bind('context', () => Fx.getFiberContext),
     Fx.bind('spans', () => Fx.getFiberRef(CurrentLogSpans)),
     Fx.bind('annotations', () => Fx.getFiberRef(CurrentLogAnnotations)),
+    Fx.bind('trace', () => (level >= LogLevel.Trace ? Fx.getTrace : Fx.now<Trace>(EmptyTrace))),
     Fx.flatMap(
-      ({ context, spans, annotations }) =>
+      ({ context, spans, annotations, trace }) =>
         context.logger.log(
           msg,
           level,
           context.id,
           Array.from(spans.values()),
           Array.from(annotations.values()),
+          trace,
         ),
       __trace,
     ),

package/src/Fx/run.ts

@@ -2,18 +2,24 @@ import { pipe } from 'hkt-ts'
 
 import { Of, getFiberContext, map } from './Fx.js'
 
+import { Atomic } from '@/Atomic/index.js'
+import { AnyLiveFiber } from '@/Fiber/Fiber.js'
 import { FiberContext } from '@/FiberContext/FiberContext.js'
 import { FiberId } from '@/FiberId/FiberId.js'
 import { Platform } from '@/Platform/Platform.js'
 import { Runtime } from '@/Runtime/index.js'
 import { GlobalScope } from '@/Scope/GlobalScope.js'
+import { trackIn } from '@/Supervisor/trackIn.js'
 
+export const RootFibers = Atomic<ReadonlyMap<FiberId.Live, AnyLiveFiber>>(new Map())
+export const MainSupervisor = trackIn(RootFibers)
 export const MainPlatform = Platform()
 export const MainRuntime = Runtime(
   FiberContext({
     platform: MainPlatform,
-    id: FiberId.None as any,
+    id: FiberId.None,
     scope: GlobalScope,
+    supervisor: MainSupervisor,
   }),
 )
 

package/src/Fx/scheduler.ts

@@ -54,7 +54,7 @@ export function schedule(schedule: Schedule.Schedule) {
       Fx.bind('env', () => Fx.getEnv<R>()),
       Fx.bind('context', () => Fx.getFiberContext),
       Fx.map(({ scheduler, env, context }) =>
-        scheduler.schedule(fx, schedule, env, context.fork()),
+        scheduler.schedule(fx, env, schedule, context.fork()),
       ),
     )
 }

package/src/Fx/scoped.ts

@@ -1,15 +1,6 @@
 import { pipe } from 'hkt-ts/function'
 
-import {
-  Fx,
-  ask,
-  ensuring,
-  getEnv,
-  getFiberContext,
-  provide,
-  provideService,
-  uninterruptable,
-} from './Fx.js'
+import * as Fx from './Fx.js'
 
 import { ConcurrentStrategy, FinalizationStrategy } from '@/Finalizer/Finalizer.js'
 import { Scope } from '@/Scope/Scope.js'
@@ -18,35 +9,36 @@ import { Scope } from '@/Scope/Scope.js'
  * Run a Scoped Fx within an isolated Scope, cleaning up those resources as soon as complete.
  */
 export function scoped<R, E, A>(
-  scoped: Fx<R | Scope, E, A>,
+  scoped: Fx.Fx<R | Scope, E, A>,
   strategy: FinalizationStrategy = ConcurrentStrategy,
-): Fx<Exclude<R, Scope>, E, A> {
-  return Fx(function* () {
-    const { scope: fiberScope } = yield* getFiberContext
-    const scope = fiberScope.fork(strategy)
+): Fx.Fx<Exclude<R, Scope>, E, A> {
+  return pipe(
+    Fx.getFiberContext,
+    Fx.flatMap(({ scope: fiberScope }) => {
+      const scope = fiberScope.fork(strategy)
 
-    return yield* pipe(scoped, provideService(Scope, scope), ensuring(scope.close))
-  })
+      return pipe(scoped, Fx.provideService(Scope, scope), Fx.ensuring(scope.close))
+    }),
+  )
 }
 
 /**
  * Track a Resource within a given Scoped environment
  */
 export function managed<R, E, A, R2>(
-  acquire: Fx<R, E, A>,
-  release: (value: A) => Fx<R2, never, any>,
-): Fx<R | R2 | Scope, E, A> {
-  return uninterruptable(
-    Fx(function* () {
-      const scope = yield* ask(Scope)
-      const env = yield* getEnv<R | R2>()
-
-      const a = yield* acquire
-
-      scope.ensuring(() => pipe(a, release, provide(env)))
-
-      return a
-    }),
+  acquire: Fx.Fx<R, E, A>,
+  release: (value: A) => Fx.Fx<R2, never, any>,
+): Fx.Fx<R | R2 | Scope, E, A> {
+  return pipe(
+    Fx.ask(Scope),
+    Fx.bindTo('scope'),
+    Fx.bind('env', () => Fx.getEnv<R | R2>()),
+    Fx.bind('a', () => acquire),
+    Fx.tap(({ scope, env, a }) =>
+      Fx.fromLazy(() => scope.ensuring(() => pipe(a, release, Fx.provide(env)))),
+    ),
+    Fx.map(({ a }) => a),
+    Fx.uninterruptable,
   )
 }
 
@@ -54,24 +46,21 @@ export function managed<R, E, A, R2>(
  * Perform an effect with an aquired resource with the release of that resource.
  */
 export function bracket<R, E, A, R2, E2, B, R3>(
-  acquire: Fx<R, E, A>,
-  withResource: (a: A) => Fx<R2, E2, B>,
-  release: (a: A) => Fx<R3, never, unknown>,
-): Fx<Scope | R | R2 | R3, E | E2, B> {
-  return Fx(function* () {
-    const a: A = yield* managed(acquire, release)
-
-    return yield* withResource(a)
-  })
+  acquire: Fx.Fx<R, E, A>,
+  withResource: (a: A) => Fx.Fx<R2, E2, B>,
+  release: (a: A) => Fx.Fx<R3, never, unknown>,
+): Fx.Fx<Scope | R | R2 | R3, E | E2, B> {
+  return pipe(managed(acquire, release), Fx.flatMap(withResource))
 }
 
 /**
  * Run a Scoped Fx within an isolated Scope, cleaning up those resources as soon as complete.
  */
-export function fiberScoped<R, E, A>(scoped: Fx<R | Scope, E, A>): Fx<Exclude<R, Scope>, E, A> {
-  return Fx(function* () {
-    const { scope } = yield* getFiberContext
-
-    return yield* pipe(scoped, provideService(Scope, scope))
-  })
+export function fiberScoped<R, E, A>(
+  scoped: Fx.Fx<R | Scope, E, A>,
+): Fx.Fx<Exclude<R, Scope>, E, A> {
+  return pipe(
+    Fx.getFiberContext,
+    Fx.flatMap(({ scope }) => pipe(scoped, Fx.provideService(Scope, scope))),
+  )
 }

package/src/Layer/Layer.ts

@@ -4,11 +4,6 @@ import * as Fx from '@/Fx/Fx.js'
 import { Scope } from '@/Scope/Scope.js'
 import { Service } from '@/Service/Service.js'
 
-// TODO: Global Layers
-// TODO: Refreshing
-// TODO: Combinators for providing fallbacks
-// TODO: Combinators for composing layers
-
 export interface Layer<R, E, A> {
   readonly service: Service<A>
   readonly build: (scope: Scope) => Fx.Fx<R, E, A>
@@ -42,3 +37,14 @@ export function fromFx<S, R, E, A extends S>(
 ): Layer<R, E, S> {
   return Layer(s, (scope) => pipe(fx, Fx.provideService(Scope, scope)))
 }
+
+export function orElse<E, A, R2, E2, B extends A>(orElse: (e: E) => Layer<R2, E2, B>) {
+  return <R>(layer: Layer<R, E, A>): Layer<R | R2, E2, A> => {
+    return Layer(layer.service, (scope) =>
+      pipe(
+        layer.build(scope),
+        Fx.orElse((e) => orElse(e).build(scope)),
+      ),
+    )
+  }
+}

package/src/Logger/Console.test.ts

@@ -1,10 +1,14 @@
-import { runTest } from '@/Fx/Fx.test.js'
-import { log, span } from '@/Fx/logging.js'
+import { addCustomTrace } from '@/Fx/index.js'
+import { annotate, logTrace, span } from '@/Fx/logging.js'
+import { runMain } from '@/Fx/run.js'
+import { testSuite } from '@/_internal/suite.js'
 
-describe(new URL(import.meta.url).pathname, () => {
+testSuite(import.meta.url, () => {
   it('allows logging to the console', async () => {
-    const test = span('foo')(log('test'))
+    const test = addCustomTrace('outer')(
+      span('foo')(annotate('bar', 'baz')(addCustomTrace('inner')(logTrace('test')))),
+    )
 
-    await runTest(test)
+    await runMain(test)
   })
 })