@typed/fx 0.0.3 → 0.0.4

package/src/Env/Env.ts

@@ -1,13 +1,6 @@
-import { pipe } from 'hkt-ts'
-import * as Maybe from 'hkt-ts/Maybe'
-
-// eslint-disable-next-line import/no-cycle
-import * as FiberRef from '@/FiberRef/index.js'
-// eslint-disable-next-line import/no-cycle
+import { getServiceFromFiberRefs } from '@/FiberRef/builtins.js'
 import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
-import { Fx, Of, fromExit } from '@/Fx/Fx.js'
-// eslint-disable-next-line import/no-cycle
-import { join } from '@/Fx/join.js'
+import { Of } from '@/Fx/Fx.js'
 import { Service } from '@/Service/Service.js'
 
 export interface Env<R> {
@@ -16,47 +9,6 @@ export interface Env<R> {
 
 export function Env<R>(fiberRefs: FiberRefs.FiberRefs): Env<R> {
   return {
-    get: get(fiberRefs), // Always use a snapshot of the FiberRefs to avoid mutability problems.
-  }
-}
-
-function get(fiberRefs: FiberRefs.FiberRefs) {
-  return <S>(id: Service<S>): Of<S> => {
-    return Fx(function* () {
-      const service = pipe(
-        fiberRefs,
-        FiberRefs.maybeGetFiberRefStack(FiberRef.Services),
-        Maybe.flatMap((s) => s.value.get(id)),
-      )
-
-      if (Maybe.isJust(service)) {
-        return service.value as S
-      }
-
-      const layers = FiberRefs.maybeGetFiberRefStack(FiberRef.Layers)(fiberRefs)
-      const layer = pipe(
-        layers,
-        Maybe.flatMap((s) => s.value.get(id)),
-      )
-
-      if (Maybe.isNothing(layers) || Maybe.isNothing(layer)) {
-        throw new Error(`Unable to find Layer or Service for ${id.description}`)
-      }
-
-      const [makeFiber, currentFiber] = layer.value
-
-      if (Maybe.isJust(currentFiber)) {
-        return (yield* fromExit(yield* currentFiber.value.exit)) as S
-      }
-
-      const fiber = makeFiber()
-
-      FiberRefs.setFiberRef(
-        FiberRef.Layers,
-        layers.value.value.set(id, [makeFiber, Maybe.Just(fiber)]),
-      )(fiberRefs)
-
-      return (yield* join(fiber)) as S
-    })
+    get: getServiceFromFiberRefs(fiberRefs),
   }
 }

package/src/Exit/hkt.ts

@@ -1,7 +1,9 @@
-import { HKT2, Params, flow, pipe } from 'hkt-ts'
-import { Left, Right, match } from 'hkt-ts/Either'
+import { HKT2, Params, Variance, flow, pipe } from 'hkt-ts'
+import * as Either from 'hkt-ts/Either'
 import * as B from 'hkt-ts/Typeclass/Bicovariant'
+import { Bottom2 } from 'hkt-ts/Typeclass/Bottom'
 import * as C from 'hkt-ts/Typeclass/Covariant'
+import { Top2 } from 'hkt-ts/Typeclass/Top'
 
 import { Exit } from './Exit.js'
 
@@ -9,10 +11,15 @@ import * as Cause from '@/Cause/index.js'
 
 export interface ExitHKT extends HKT2 {
   readonly type: Exit<this[Params.E], this[Params.A]>
+  readonly defaults: {
+    readonly [Params.E]: Variance.Covariant<unknown>
+    readonly [Params.A]: Variance.Covariant<unknown>
+  }
 }
 
 export const Bicovariant: B.Bicovariant2<ExitHKT> = {
-  bimap: (f, g) => (exit) => pipe(exit, match(flow(Cause.map(f), Left), flow(g, Right))),
+  bimap: (f, g) => (exit) =>
+    pipe(exit, Either.match(flow(Cause.map(f), Either.Left), flow(g, Either.Right))),
 }
 
 export const bimap = Bicovariant.bimap
@@ -27,3 +34,11 @@ export const bindTo = C.bindTo(Covariant)
 export const flap = C.flap(Covariant)
 export const mapTo = C.mapTo(Covariant)
 export const tupled = C.tupled(Covariant)
+
+export const Top = Either.Top as Top2<ExitHKT>
+export const top = Top.top
+
+export const Bottom: Bottom2<ExitHKT> = {
+  bottom: Either.Left(Cause.Empty),
+}
+export const bottom = Bottom.bottom

package/src/Fiber/Fiber.ts

@@ -3,10 +3,9 @@ import { flow, pipe } from 'hkt-ts/function'
 import type { Exit } from '@/Exit/Exit.js'
 import type { FiberContext } from '@/FiberContext/FiberContext.js'
 import type { FiberId } from '@/FiberId/FiberId.js'
-// eslint-disable-next-line import/no-cycle
 import { join } from '@/FiberRefs/FiberRefs.js'
 import type { FiberStatus } from '@/FiberStatus/index.js'
-import { Fx, Of, flatMap, fork, fromLazy, getFiberContext } from '@/Fx/Fx.js'
+import { Of, flatMap, fork, fromExit, getFiberContext, map } from '@/Fx/Fx.js'
 import type { Trace } from '@/Trace/Trace.js'
 
 export type Fiber<E, A> = Live<E, A> | Synthetic<E, A>
@@ -31,20 +30,20 @@ export interface Live<E, A> {
 
 export type AnyLiveFiber = Live<any, any> | Live<never, never> | Live<any, never> | Live<never, any>
 
-export const Live = <E, A>(params: Omit<Live<E, A>, 'tag'>): Live<E, A> => ({
+export const Live = <E, A>(params: Omit<Live<E, A>, 'tag'>): Fiber<E, A> => ({
   tag: 'Live',
   ...params,
 })
 
 export interface Synthetic<E, A> {
   readonly tag: 'Synthetic'
-  readonly id: FiberId.Synthetic
+  readonly id: FiberId
   readonly exit: Of<Exit<E, A>>
   readonly inheritFiberRefs: Of<void>
   readonly interruptAs: (id: FiberId) => Of<Exit<E, A>>
 }
 
-export const Synthetic = <E, A>(params: Omit<Synthetic<E, A>, 'tag'>): Synthetic<E, A> => ({
+export const Synthetic = <E, A>(params: Omit<Synthetic<E, A>, 'tag'>): Fiber<E, A> => ({
   tag: 'Synthetic',
   ...params,
 })
@@ -54,23 +53,25 @@ export const match =
   (fiber: Fiber<E, A>) =>
     fiber.tag === 'Live' ? onLive(fiber) : onSynthetic(fiber)
 
-export const inheritFiberRefs = <E, A>(fiber: Fiber<E, A>) =>
-  Fx(function* () {
-    if (fiber.tag === 'Synthetic') {
-      return yield* fiber.inheritFiberRefs
-    }
-
-    const { fiberRefs } = yield* getFiberContext
-
-    yield* fromLazy(() => join(fiberRefs, fiber.context.fiberRefs))
-  })
+export const inheritFiberRefs = <E, A>(fiber: Fiber<E, A>): Of<void> =>
+  pipe(
+    fiber,
+    match(
+      (l) =>
+        pipe(
+          getFiberContext,
+          map((c) => join(c.fiberRefs, l.context.fiberRefs)),
+        ),
+      (s) => s.inheritFiberRefs,
+    ),
+  )
 
 export const interruptAs =
   (id: FiberId) =>
   <E, A>(fiber: Fiber<E, A>) =>
     fiber.interruptAs(id)
 
-export const interruptAsFork = (id: FiberId) => flow(interruptAs(id), fork)
+export const interruptAsFork = (id: FiberId) => flow(interruptAs(id), flatMap(fromExit), fork)
 
 export const interrupt = <E, A>(fiber: Fiber<E, A>) =>
   pipe(

package/src/Fiber/fromExit.ts

@@ -0,0 +1,14 @@
+import { Fiber, Synthetic } from './Fiber.js'
+
+import { Exit } from '@/Exit/Exit.js'
+import { FiberId } from '@/FiberId/FiberId.js'
+import { now, unit } from '@/Fx/index.js'
+
+export function fromExit<E, A>(exit: Exit<E, A>): Fiber<E, A> {
+  return Synthetic({
+    id: new FiberId.Synthetic([]),
+    exit: now(exit),
+    inheritFiberRefs: unit,
+    interruptAs: () => now(exit),
+  })
+}

package/src/Fiber/hkt.ts

@@ -0,0 +1,125 @@
+import { makeAssociative } from 'hkt-ts/Array'
+import { HKT2, Params } from 'hkt-ts/HKT'
+import * as AB from 'hkt-ts/Typeclass/AssociativeBoth'
+import * as B from 'hkt-ts/Typeclass/Bicovariant'
+import { Bottom2 } from 'hkt-ts/Typeclass/Bottom'
+import { CommutativeBoth2 } from 'hkt-ts/Typeclass/CommutativeBoth'
+import * as C from 'hkt-ts/Typeclass/Covariant'
+import * as IB from 'hkt-ts/Typeclass/IdentityBoth'
+import { Top2 } from 'hkt-ts/Typeclass/Top'
+import { flow, pipe } from 'hkt-ts/function'
+
+import { Fiber, Synthetic, inheritFiberRefs } from './Fiber.js'
+import { fromExit } from './fromExit.js'
+
+import * as Exit from '@/Exit/index.js'
+import * as FiberId from '@/FiberId/FiberId.js'
+import * as Fx from '@/Fx/Fx.js'
+
+export interface FiberHKT extends HKT2 {
+  readonly type: Fiber<this[Params.E], this[Params.A]>
+}
+
+export const Bicovariant: B.Bicovariant2<FiberHKT> = {
+  bimap: (f, g) => (fiber) =>
+    Synthetic({
+      id: FiberId.Synthetic([fiber.id]),
+      exit: pipe(fiber.exit, Fx.map(Exit.bimap(f, g))),
+      inheritFiberRefs: inheritFiberRefs(fiber),
+      interruptAs: flow(fiber.interruptAs, Fx.map(Exit.bimap(f, g))),
+    }),
+}
+
+export const bimap = Bicovariant.bimap
+export const mapLeft = B.mapLeft(Bicovariant)
+export const map = B.map(Bicovariant)
+
+export const Covariant: C.Covariant2<FiberHKT> = {
+  map,
+}
+
+export const bindTo = C.bindTo(Covariant)
+export const flap = C.flap(Covariant)
+export const mapTo = C.mapTo(Covariant)
+export const tupled = C.tupled(Covariant)
+
+export const Top: Top2<FiberHKT> = {
+  top: fromExit(Exit.top),
+}
+export const top = Top.top
+
+export const Bottom: Bottom2<FiberHKT> = {
+  bottom: fromExit(Exit.bottom),
+}
+export const bottom = Bottom.bottom
+
+const concatExitSeq = Exit.makeSequentialAssociative<any, any>(makeAssociative<any>()).concat
+
+export const AssociativeBoth: AB.AssociativeBoth2<FiberHKT> = {
+  both: (fb) => (fa) =>
+    Synthetic({
+      id: FiberId.Synthetic([fa.id, fb.id]),
+      exit: pipe(
+        Fx.zipAllSeq([fa.exit, fb.exit]),
+        Fx.flatMap(([ea, eb]) => Fx.now(concatExitSeq(Exit.tupled(ea), Exit.tupled(eb)))),
+      ),
+      inheritFiberRefs: pipe(
+        inheritFiberRefs(fa),
+        Fx.flatMap(() => inheritFiberRefs(fb)),
+      ),
+      interruptAs: (id) =>
+        pipe(
+          Fx.zipAllSeq([fa.interruptAs(id), fb.interruptAs(id)]),
+          Fx.map(([ea, eb]) => concatExitSeq(Exit.tupled(ea), Exit.tupled(eb))),
+        ),
+    }),
+}
+
+export const bothSeq = AssociativeBoth.both
+
+export const zipLeftSeq = AB.zipLeft<FiberHKT>({ ...AssociativeBoth, ...Covariant })
+export const zipRightSeq = AB.zipRight<FiberHKT>({ ...AssociativeBoth, ...Covariant })
+
+const concatExitPar = Exit.makeParallelAssociative<any, any>(makeAssociative<any>()).concat
+
+export const CommutativeBoth: CommutativeBoth2<FiberHKT> = {
+  both: (fb) => (fa) =>
+    Synthetic({
+      id: FiberId.Synthetic([fa.id, fb.id]),
+      exit: pipe(
+        Fx.zipAll([fa.exit, fb.exit]),
+        Fx.flatMap(([ea, eb]) => Fx.now(concatExitPar(Exit.tupled(ea), Exit.tupled(eb)))),
+      ),
+      inheritFiberRefs: pipe(
+        inheritFiberRefs(fa),
+        Fx.flatMap(() => inheritFiberRefs(fb)),
+      ),
+      interruptAs: (id) =>
+        pipe(
+          Fx.zipAll([fa.interruptAs(id), fb.interruptAs(id)]),
+          Fx.map(([ea, eb]) => concatExitPar(Exit.tupled(ea), Exit.tupled(eb))),
+        ),
+    }),
+}
+
+export const both = CommutativeBoth.both
+export const zipLeft = AB.zipLeft<FiberHKT>({ ...CommutativeBoth, ...Covariant })
+export const zipRight = AB.zipRight<FiberHKT>({ ...CommutativeBoth, ...Covariant })
+
+export const IdentityBothSeq: IB.IdentityBoth2<FiberHKT> = {
+  ...AssociativeBoth,
+  ...Top,
+}
+
+export const tupleSeq = IB.tuple<FiberHKT>({ ...IdentityBothSeq, ...Covariant })
+export const structSeq = IB.struct<FiberHKT>({ ...IdentityBothSeq, ...Covariant })
+
+export const IdentityBothPar: IB.IdentityBoth2<FiberHKT> = {
+  ...CommutativeBoth,
+  ...Top,
+}
+
+export const tuple = IB.tuple<FiberHKT>({ ...IdentityBothPar, ...Covariant })
+export const struct = IB.struct<FiberHKT>({ ...IdentityBothPar, ...Covariant })
+
+// TODO: More Typeclass instances

package/src/Fiber/index.ts

@@ -1 +1,2 @@
 export * from './Fiber.js'
+export * from './hkt.js'

package/src/FiberContext/FiberContext.ts

@@ -1,6 +1,5 @@
 import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
 
-import { Renderer, defaultRenderer } from '@/Cause/Renderer.js'
 import * as FiberId from '@/FiberId/FiberId.js'
 import { FiberRefs } from '@/FiberRefs/FiberRefs.js'
 import { SequentialStrategy } from '@/Finalizer/Finalizer.js'
@@ -11,52 +10,54 @@ import { Closeable } from '@/Scope/Closeable.js'
 import { LocalScope } from '@/Scope/LocalScope.js'
 import { None, Supervisor } from '@/Supervisor/Supervisor.js'
 
-export interface FiberContext {
-  readonly id: FiberId.Live
+export interface FiberContext<Id extends FiberId.FiberId = FiberId.FiberId> {
+  readonly id: Id
   readonly platform: Platform
   readonly fiberRefs: FiberRefs
   readonly scope: Closeable
   readonly supervisor: Supervisor<any>
   readonly logger: Logger<string, any>
-  readonly renderer: Renderer<any>
   readonly parent: Maybe<FiberContext>
 
-  readonly fork: (overrides?: Partial<FiberContext>) => FiberContext
+  readonly fork: <Id2 extends FiberId.FiberId = FiberId.Live>(
+    overrides?: Partial<FiberContext<Id2>>,
+  ) => FiberContext<Id2>
 }
 
-export function FiberContext(params: Partial<Omit<FiberContext, 'fork'>> = {}): FiberContext {
+export function FiberContext<Id extends FiberId.FiberId = FiberId.Live>(
+  params: Partial<Omit<FiberContext<Id>, 'fork'>> = {},
+): FiberContext<Id> {
   const {
     platform = Platform(),
-    id = FiberId.Live(platform),
+    id = FiberId.Live(platform) as Id,
     fiberRefs = FiberRefs(),
     scope = new LocalScope(SequentialStrategy),
     supervisor = None,
     logger = Console,
-    renderer = defaultRenderer,
     parent = Nothing,
   } = params
 
-  const context: FiberContext = {
+  const context: FiberContext<Id> = {
     id,
     platform,
     fiberRefs,
     scope,
     supervisor,
     logger,
-    renderer,
     parent,
-    fork: (overrides?: Partial<FiberContext>) => fork(context, overrides),
+    fork: ((overrides?: Partial<FiberContext>) =>
+      fork(context, overrides)) as FiberContext<Id>['fork'],
   }
 
   return context
 }
 
-export function fork(
-  context: FiberContext,
-  overrides?: Partial<Omit<FiberContext, 'fork'>>,
-): FiberContext {
+export function fork<Id extends FiberId.FiberId = FiberId.Live, Id2 extends FiberId.FiberId = Id>(
+  context: FiberContext<Id>,
+  overrides?: Partial<Omit<FiberContext<Id2>, 'fork'>>,
+): FiberContext<Id2> {
   return FiberContext({
-    id: overrides?.id ?? FiberId.Live(context.platform),
+    id: (overrides?.id ?? FiberId.Live(context.platform)) as Id2,
     platform: overrides?.platform ?? context.platform.fork(),
     fiberRefs: overrides?.fiberRefs ?? context.fiberRefs.fork(),
     scope: overrides?.scope ?? context.scope.fork(),

package/src/FiberId/FiberId.ts

@@ -10,7 +10,7 @@ import * as S from 'hkt-ts/string'
 
 import { increment } from '@/Atomic/AtomicCounter.js'
 import { Clock, timeToDate } from '@/Clock/Clock.js'
-import { Platform } from '@/Platform/Platform.js'
+import type { Platform } from '@/Platform/Platform.js'
 import { Time } from '@/Time/index.js'
 
 export type FiberId = FiberId.None | FiberId.Live | FiberId.Synthetic

package/src/FiberRef/FiberRef.ts

@@ -1,19 +1,8 @@
-import { constant, identity, pipe } from 'hkt-ts'
-import { Just, Maybe, Nothing } from 'hkt-ts/Maybe'
+import { Just, Maybe } from 'hkt-ts/Maybe'
 import { Second } from 'hkt-ts/Typeclass/Concat'
 import { DeepEquals, Eq } from 'hkt-ts/Typeclass/Eq'
-import { NonNegativeInteger } from 'hkt-ts/number'
 
-// eslint-disable-next-line import/no-cycle
-import { Env } from '@/Env/Env.js'
-import type { Live } from '@/Fiber/Fiber.js'
-import { Fx, getFiberContext, map, now } from '@/Fx/Fx.js'
-import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
-import { LogAnnotation } from '@/Logger/LogAnnotation.js'
-import { LogSpan } from '@/Logger/LogSpan.js'
-import { Semaphore } from '@/Semaphore/Semaphore.js'
-import { Service } from '@/Service/Service.js'
-import { EmptyTrace, Trace } from '@/Trace/Trace.js'
+import { type Fx } from '@/Fx/Fx.js'
 
 export class FiberRef<R, E, A> {
   constructor(
@@ -32,11 +21,7 @@ export type ErrorsOf<T> = T extends FiberRef<infer _R, infer _E, infer _A> ? _E
 export type OutputOf<T> = T extends FiberRef<infer _R, infer _E, infer _A> ? _A : never
 /* eslint-enable @typescript-eslint/no-unused-vars */
 
-export type AnyFiberRef =
-  | FiberRef<any, any, any>
-  | FiberRef<never, never, any>
-  | FiberRef<never, any, any>
-  | FiberRef<any, never, any>
+export type AnyFiberRef = FiberRef<any, any, any>
 
 export function make<R, E, A>(initial: Fx<R, E, A>, params: Params<A> = {}): FiberRef<R, E, A> {
   return new FiberRef(initial, params.fork, params.join, params.Eq)
@@ -47,48 +32,3 @@ export type Params<A> = {
   readonly join?: (current: A, incoming: A) => A
   readonly Eq?: Eq<A>
 }
-
-export const CurrentEnv = make(
-  pipe(
-    getFiberContext,
-    map((c) => Env<any>(c.fiberRefs)),
-  ),
-  {
-    fork: constant(Nothing), // Always create a new Env for each Fiber.
-    join: identity, // Always keep the parent Fiber's Env
-  },
-)
-
-export const CurrentConcurrencyLevel = make(
-  now<Semaphore>(new Semaphore(NonNegativeInteger(Infinity))),
-  {
-    join: identity, // Always keep the parent Fiber's concurrency level
-  },
-)
-
-export const CurrentInterruptStatus = make(now<boolean>(true), {
-  join: identity, // Always keep the parent Fiber's interrupt status
-})
-
-export const CurrentTrace = make(now<Trace>(EmptyTrace), {
-  join: identity, // Always keep the parent Fiber's trace
-})
-
-export const Layers = FiberRef.make(
-  now(ImmutableMap<Service<any>, readonly [() => Live<never, any>, Maybe<Live<never, any>>]>()),
-  {
-    join: identity, // Always keep the parent Fiber's layers
-  },
-)
-
-export const Services = FiberRef.make(now(ImmutableMap<Service<any>, any>()), {
-  join: identity, // Always keep the parent Fiber's services
-})
-
-export const CurrentLogSpans = FiberRef.make(now(ImmutableMap<string, LogSpan>()), {
-  join: identity,
-})
-
-export const CurrentLogAnnotations = FiberRef.make(now(ImmutableMap<string, LogAnnotation>()), {
-  join: identity,
-})

package/src/FiberRef/builtins.ts

@@ -0,0 +1,114 @@
+import { Maybe, constant, identity, pipe } from 'hkt-ts'
+import { Nothing } from 'hkt-ts/Maybe'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { FiberRef, make } from './FiberRef.js'
+
+import type { Env } from '@/Env/Env.js'
+import { Live } from '@/Fiber/Fiber.js'
+import * as FiberRefs from '@/FiberRefs/FiberRefs.js'
+import * as Fx from '@/Fx/Fx.js'
+import { join } from '@/Fx/join.js'
+import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
+import { LogAnnotation } from '@/Logger/LogAnnotation.js'
+import { LogSpan } from '@/Logger/LogSpan.js'
+import { Semaphore } from '@/Semaphore/Semaphore.js'
+import { Service } from '@/Service/Service.js'
+import { Trace } from '@/Trace/Trace.js'
+
+export const CurrentEnv = make(
+  pipe(
+    Fx.getFiberContext,
+    // Always use a snapshot of the FiberRefs to avoid mutability problems.
+    Fx.map((c): Env<any> => ({ get: getServiceFromFiberRefs(c.fiberRefs) })),
+  ),
+  {
+    fork: constant(Nothing), // Always create a new Env for each Fiber.
+    join: identity, // Always keep the parent Fiber's Env
+  },
+)
+
+export const CurrentConcurrencyLevel = make(
+  Fx.fromLazy(() => new Semaphore(NonNegativeInteger(Infinity))),
+  {
+    join: identity, // Always keep the parent Fiber's concurrency level
+  },
+)
+
+export const CurrentInterruptStatus = make(Fx.now(true), {
+  join: identity, // Always keep the parent Fiber's interrupt status
+})
+
+export const CurrentTrace = make(
+  Fx.fromLazy<Trace>(() => Trace.runtime(new Error())),
+  {
+    join: identity, // Always keep the parent Fiber's trace
+  },
+)
+
+export const Layers = FiberRef.make(
+  Fx.fromLazy(() =>
+    ImmutableMap<Service<any>, readonly [() => Live<never, any>, Maybe.Maybe<Live<never, any>>]>(),
+  ),
+  {
+    join: identity, // Always keep the parent Fiber's layers
+  },
+)
+
+export const Services = FiberRef.make(Fx.now(ImmutableMap<Service<any>, any>()), {
+  join: identity, // Always keep the parent Fiber's services
+})
+
+export const CurrentLogSpans = FiberRef.make(Fx.now(ImmutableMap<string, LogSpan>()), {
+  join: identity,
+})
+
+export const CurrentLogAnnotations = FiberRef.make(Fx.now(ImmutableMap<string, LogAnnotation>()), {
+  join: identity,
+})
+
+export function getServiceFromFiberRefs(fiberRefs: FiberRefs.FiberRefs) {
+  return <S>(id: Service<S>): Fx.Of<S> => {
+    return Fx.lazy(() => {
+      const service = pipe(
+        fiberRefs,
+        FiberRefs.maybeGetFiberRefValue(Services),
+        Maybe.flatMap((s) => s.get(id)),
+      )
+
+      if (Maybe.isJust(service)) {
+        return Fx.success(service.value as S)
+      }
+
+      return getLayerFromFiberRefs(id, fiberRefs)
+    })
+  }
+}
+
+const getLayerFromFiberRefs = <S>(id: Service<S>, fiberRefs: FiberRefs.FiberRefs) =>
+  Fx.lazy(() => {
+    const layers = FiberRefs.maybeGetFiberRefValue(Layers)(fiberRefs)
+
+    // Add Layers if it is missing
+    if (Maybe.isNothing(layers)) {
+      throw new Error(`Unable to find Layer or Service for ${id.description}`)
+    }
+
+    const layer = layers.value.get(id)
+
+    if (Maybe.isNothing(layer)) {
+      throw new Error(`Unable to find Layer or Service for ${id.description}`)
+    }
+
+    const [makeFiber, currentFiber] = layer.value
+
+    if (Maybe.isJust(currentFiber)) {
+      return pipe(currentFiber.value.exit, Fx.flatMap(Fx.fromExit))
+    }
+
+    const fiber = makeFiber()
+
+    FiberRefs.setFiberRef(Layers, layers.value.set(id, [makeFiber, Maybe.Just(fiber)]))(fiberRefs)
+
+    return join(fiber)
+  })

package/src/FiberRef/index.ts

@@ -1,3 +1,2 @@
-// eslint-disable-next-line import/no-cycle
 export * from './FiberRef.js'
 export * from './operations.js'