@typed/fx 0.0.1

package/src/Exit/Exit.ts

@@ -0,0 +1,50 @@
+import { pipe } from 'hkt-ts'
+import * as Either from 'hkt-ts/Either'
+import { Associative } from 'hkt-ts/Typeclass'
+import { Eq } from 'hkt-ts/Typeclass/Eq'
+import { Identity } from 'hkt-ts/Typeclass/Identity'
+
+import * as Cause from '@/Cause/Cause.js'
+import type * as FiberId from '@/FiberId/FiberId.js'
+
+export type Exit<E, A> = Either.Either<Cause.Cause<E>, A>
+
+export type AnyExit = Exit<any, any>
+
+export const success = <A>(value: A): Exit<never, A> => Either.Right(value)
+
+export const interrupt = (fiberId: FiberId.FiberId): Exit<never, never> =>
+  Either.Left(Cause.interrupted(fiberId))
+
+export const unexpected = (error: unknown): Exit<never, never> =>
+  Either.Left(Cause.unexpected(error))
+
+export const expected = <E>(error: E): Exit<E, never> => Either.Left(Cause.expected(error))
+
+export const fromEither = <E, A>(either: Either.Either<E, A>): Exit<E, A> =>
+  pipe(
+    either,
+    Either.mapLeft((e) => Cause.expected(e)),
+  )
+
+export const makeParallelAssociative = <A, E = never>(
+  A: Associative.Associative<A>,
+): Associative.Associative<Exit<E, A>> =>
+  Either.makeAssociative(Cause.makeParallelAssociative<E>(), A)
+
+export const makeSequentialAssociative = <A, E = never>(
+  A: Associative.Associative<A>,
+): Associative.Associative<Exit<E, A>> =>
+  Either.makeAssociative(Cause.makeSequentialAssociative<E>(), A)
+
+export const makeParallelIdentity = <A, E = never>(A: Identity<A>): Identity<Exit<E, A>> =>
+  Either.makeIdentity(Cause.makeParallelAssociative<E>(), A)
+
+export const makeSequentialIdentity = <A, E = never>(A: Identity<A>): Identity<Exit<E, A>> =>
+  Either.makeIdentity(Cause.makeSequentialAssociative<E>(), A)
+
+export const makeParallelBottom = <E>() => Either.makeBottom(Cause.makeParallelIdentity<E>())
+export const makeSequentialBottom = <E>() => Either.makeBottom(Cause.makeSequentialIdentity<E>())
+
+export const makeEq = <E, A>(E: Eq<E>, A: Eq<A>): Eq<Exit<E, A>> =>
+  Either.makeEq(Cause.makeEq(E), A)

package/src/Exit/hkt.ts

@@ -0,0 +1,29 @@
+import { HKT2, Params, flow, pipe } from 'hkt-ts'
+import { Left, Right, match } from 'hkt-ts/Either'
+import * as B from 'hkt-ts/Typeclass/Bicovariant'
+import * as C from 'hkt-ts/Typeclass/Covariant'
+
+import { Exit } from './Exit.js'
+
+import * as Cause from '@/Cause/index.js'
+
+export interface ExitHKT extends HKT2 {
+  readonly type: Exit<this[Params.E], this[Params.A]>
+}
+
+export const Bicovariant: B.Bicovariant2<ExitHKT> = {
+  bimap: (f, g) => (exit) => pipe(exit, match(flow(Cause.map(f), Left), flow(g, Right))),
+}
+
+export const bimap = Bicovariant.bimap
+export const mapLeft = B.mapLeft(Bicovariant)
+export const map = B.map(Bicovariant)
+
+export const Covariant: C.Covariant2<ExitHKT> = {
+  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)

package/src/Exit/index.ts

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

package/src/Fiber/Fiber.ts

@@ -0,0 +1,85 @@
+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 type { Trace } from '@/Trace/Trace.js'
+
+export type Fiber<E, A> = Live<E, A> | Synthetic<E, A>
+
+export type AnyFiber = Fiber<any, any> | Fiber<never, never> | Fiber<any, never> | Fiber<never, any>
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export type ErrorsOf<T> = [T] extends [Fiber<infer E, infer _A>] ? E : never
+
+export type OutputOf<T> = [T] extends [Fiber<infer _E, infer A>] ? A : never
+/* eslint-enable @typescript-eslint/no-unused-vars */
+
+export interface Live<E, A> {
+  readonly tag: 'Live'
+  readonly id: FiberId.Live
+  readonly context: FiberContext
+  readonly status: Of<FiberStatus>
+  readonly exit: Of<Exit<E, A>>
+  readonly trace: Of<Trace>
+  readonly interruptAs: (id: FiberId) => Of<Exit<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> => ({
+  tag: 'Live',
+  ...params,
+})
+
+export interface Synthetic<E, A> {
+  readonly tag: 'Synthetic'
+  readonly id: FiberId.Synthetic
+  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> => ({
+  tag: 'Synthetic',
+  ...params,
+})
+
+export const match =
+  <E, A, B, C>(onLive: (live: Live<E, A>) => B, onSynthetic: (synthetic: Synthetic<E, A>) => C) =>
+  (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 interruptAs =
+  (id: FiberId) =>
+  <E, A>(fiber: Fiber<E, A>) =>
+    fiber.interruptAs(id)
+
+export const interruptAsFork = (id: FiberId) => flow(interruptAs(id), fork)
+
+export const interrupt = <E, A>(fiber: Fiber<E, A>) =>
+  pipe(
+    getFiberContext,
+    flatMap(({ id }) => interruptAs(id)(fiber)),
+  )
+
+export const interruptFork = <E, A>(fiber: Fiber<E, A>) =>
+  pipe(
+    getFiberContext,
+    flatMap(({ id }) => interruptAsFork(id)(fiber)),
+  )

package/src/Fiber/index.ts

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

package/src/FiberContext/FiberContext.ts

@@ -0,0 +1,67 @@
+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'
+import { Console } from '@/Logger/Console.js'
+import { Logger } from '@/Logger/Logger.js'
+import { Platform } from '@/Platform/Platform.js'
+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
+  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
+}
+
+export function FiberContext(params: Partial<Omit<FiberContext, 'fork'>> = {}): FiberContext {
+  const {
+    platform = Platform(),
+    id = FiberId.Live(platform),
+    fiberRefs = FiberRefs(),
+    scope = new LocalScope(SequentialStrategy),
+    supervisor = None,
+    logger = Console,
+    renderer = defaultRenderer,
+    parent = Nothing,
+  } = params
+
+  const context: FiberContext = {
+    id,
+    platform,
+    fiberRefs,
+    scope,
+    supervisor,
+    logger,
+    renderer,
+    parent,
+    fork: (overrides?: Partial<FiberContext>) => fork(context, overrides),
+  }
+
+  return context
+}
+
+export function fork(
+  context: FiberContext,
+  overrides?: Partial<Omit<FiberContext, 'fork'>>,
+): FiberContext {
+  return FiberContext({
+    id: overrides?.id ?? FiberId.Live(context.platform),
+    platform: overrides?.platform ?? context.platform.fork(),
+    fiberRefs: overrides?.fiberRefs ?? context.fiberRefs.fork(),
+    scope: overrides?.scope ?? context.scope.fork(),
+    supervisor: overrides?.supervisor ?? None,
+    logger: overrides?.logger ?? context.logger,
+    parent: overrides?.parent ?? Just(context),
+  })
+}

package/src/FiberContext/index.ts

@@ -0,0 +1 @@
+export * from './FiberContext.js'

package/src/FiberId/FiberId.ts

@@ -0,0 +1,122 @@
+import { pipe } from 'hkt-ts'
+import * as A from 'hkt-ts/Array'
+import * as ASC from 'hkt-ts/Typeclass/Associative'
+import * as D from 'hkt-ts/Typeclass/Debug'
+import * as E from 'hkt-ts/Typeclass/Eq'
+import * as I from 'hkt-ts/Typeclass/Identity'
+import * as O from 'hkt-ts/Typeclass/Ord'
+import * as N from 'hkt-ts/number'
+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 { Time } from '@/Time/index.js'
+
+export type FiberId = FiberId.None | FiberId.Live | FiberId.Synthetic
+
+export namespace FiberId {
+  export interface None {
+    readonly tag: 'None'
+  }
+
+  export const None: None = { tag: 'None' }
+
+  export class Live {
+    static readonly tag = 'Live'
+    readonly tag = Live.tag
+    constructor(
+      readonly sequenceNumber: N.NonNegativeInteger, // Incrementing SequenceNumber guaranteeing uniqueness
+      readonly clock: Clock, // The Clock used to create FiberId
+      readonly startTime: Time, // The monotonic Time at which this Fiber started, relative to its Clock.
+    ) {}
+  }
+
+  export class Synthetic {
+    static readonly tag = 'Synthetic'
+    readonly tag = Synthetic.tag
+
+    constructor(readonly fiberIds: ReadonlyArray<FiberId>) {}
+  }
+}
+
+export const None = FiberId.None
+export type None = FiberId.None
+
+export type Live = FiberId.Live
+export const Live = ({ sequenceNumber, timer }: Platform): FiberId.Live =>
+  new FiberId.Live(increment(sequenceNumber), timer, timer.getCurrentTime())
+
+export type Synthetic = FiberId.Synthetic
+export const Synthetic = (fiberIds: ReadonlyArray<FiberId>): FiberId.Synthetic =>
+  new FiberId.Synthetic(fiberIds)
+
+export const match =
+  <A, B, C>(
+    onNone: () => A,
+    onLive: (id: FiberId.Live) => B,
+    onSynthetic: (id: FiberId.Synthetic) => C,
+  ) =>
+  (id: FiberId): A | B | C => {
+    switch (id.tag) {
+      case 'None':
+        return onNone()
+      case 'Live':
+        return onLive(id)
+      case 'Synthetic':
+        return onSynthetic(id)
+    }
+  }
+
+export const Eq: E.Eq<FiberId> = E.sum<FiberId>()('tag')({
+  None: E.struct({ tag: E.string }),
+  Live: E.struct({
+    tag: E.string,
+    sequenceNumber: N.NonNegativeIntegerEq,
+    startTime: Time.makeEq(N.Eq),
+  }),
+  Synthetic: E.struct({ tag: E.string, fiberIds: A.makeEq(E.lazy(() => Eq)) }),
+})
+
+export const Ord: O.Ord<FiberId> = O.sum<FiberId>()('tag')(
+  pipe(
+    N.Ord,
+    O.contramap((a) => (a === 'None' ? 0 : a === 'Live' ? 1 : 2)),
+  ),
+)({
+  None: O.struct<FiberId.None>({ tag: O.Static })(S.Ord),
+  Live: O.struct({
+    sequenceNumber: N.NonNegativeIntegerOrd,
+    startTime: Time.makeOrd(N.Ord),
+    tag: O.Static,
+  })(S.Ord),
+  Synthetic: O.struct<FiberId.Synthetic>({
+    fiberIds: A.makeOrd(O.lazy(() => Ord)),
+    tag: O.Static,
+  })(S.Ord),
+})
+
+export const Associative: ASC.Associative<FiberId> = {
+  concat: (f, s) => (f.tag === None.tag ? s : s.tag === None.tag ? f : Synthetic([f, s])),
+}
+
+export const Identity: I.Identity<FiberId> = {
+  ...Associative,
+  id: None,
+}
+
+export const Debug: D.Debug<FiberId> = D.sum<FiberId>()('tag')({
+  None: {
+    debug: () => 'FiberId.None',
+  },
+  Live: {
+    debug: (id) => `Fiber #${id.sequenceNumber} (started at ${idToIsoString(id)})`,
+  },
+  Synthetic: {
+    debug: (id) => `Synthetic Fiber\n  -${id.fiberIds.map(debug).join('\n  -')}`,
+  },
+})
+
+export const debug = Debug.debug
+
+const idToIsoString = (id: FiberId.Live) => timeToDate(id.startTime)(id.clock).toISOString()

package/src/FiberId/index.ts

@@ -0,0 +1 @@
+export * from './FiberId.js'

package/src/FiberRef/FiberRef.ts

@@ -0,0 +1,93 @@
+import { identity, pipe } from 'hkt-ts'
+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'
+
+export class FiberRef<R, E, A> {
+  constructor(
+    readonly initial: Fx<R, E, A>,
+    readonly fork: (a: A) => Maybe<A> = Just,
+    readonly join: (current: A, incoming: A) => A = Second.concat,
+    readonly Eq: Eq<A> = DeepEquals,
+  ) {}
+
+  static make = make
+}
+
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export type ResourcesOf<T> = T extends FiberRef<infer _R, infer _E, infer _A> ? _R : never
+export type ErrorsOf<T> = T extends FiberRef<infer _R, infer _E, infer _A> ? _E : never
+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 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)
+}
+
+export type Params<A> = {
+  readonly fork?: (a: A) => Maybe<A>
+  readonly join?: (current: A, incoming: A) => A
+  readonly Eq?: Eq<A>
+}
+
+export const CurrentEnv = make(
+  pipe(
+    getFiberContext,
+    map((c) => Env(c.fiberRefs)),
+  ),
+  {
+    join: identity, // Always keep the parent Fiber's concurrency level
+  },
+)
+
+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/index.ts

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

package/src/FiberRef/operations.ts

@@ -0,0 +1,19 @@
+import { deleteFiberRef, getFiberRef, modifyFiberRef } from '@/Fx/Fx.js'
+
+export const get = getFiberRef
+export const modify = modifyFiberRef
+export const remove = deleteFiberRef
+
+export { remove as delete }
+
+export const set = <A>(value: A) => modify(() => [value, value])
+export const getAndSet = <A>(value: A) => modify((a) => [a, value])
+
+export const update = <A>(f: (a: A) => A) =>
+  modify((a: A) => {
+    const a2 = f(a)
+
+    return [a2, a2]
+  })
+
+export const getAndUpdate = <A>(f: (a: A) => A) => modify((a: A) => [a, f(a)])

package/src/FiberRefs/FiberRefs.ts

@@ -0,0 +1,162 @@
+import { flow, pipe } from 'hkt-ts'
+import * as Maybe from 'hkt-ts/Maybe'
+import { NonNegativeInteger } from 'hkt-ts/number'
+
+import { Atomic } from '@/Atomic/Atomic.js'
+// eslint-disable-next-line import/no-cycle
+import * as FiberRef from '@/FiberRef/FiberRef.js'
+import { ImmutableMap } from '@/ImmutableMap/ImmutableMap.js'
+import { Semaphore } from '@/Semaphore/index.js'
+import * as Stack from '@/Stack/index.js'
+import { EmptyTrace, Trace } from '@/Trace/Trace.js'
+
+export interface FiberRefs extends Iterable<readonly [FiberRef.AnyFiberRef, any]> {
+  readonly locals: Atomic<ImmutableMap<FiberRef.AnyFiberRef, Stack.Stack<any>>>
+  readonly fork: () => FiberRefs
+}
+
+const defaultFiberLocals = (
+  concurrencyLevel: NonNegativeInteger = NonNegativeInteger(Infinity),
+  interruptStatus = true,
+  trace: Trace = EmptyTrace,
+) =>
+  new Map<FiberRef.AnyFiberRef, Stack.Stack<any>>([
+    [FiberRef.CurrentConcurrencyLevel, new Stack.Stack(new Semaphore(concurrencyLevel))],
+    [FiberRef.CurrentInterruptStatus, new Stack.Stack(interruptStatus)],
+    [FiberRef.CurrentTrace, new Stack.Stack(trace)],
+    [FiberRef.Services, new Stack.Stack(ImmutableMap())],
+    [FiberRef.Layers, new Stack.Stack(ImmutableMap())],
+    [FiberRef.CurrentLogSpans, new Stack.Stack(ImmutableMap())],
+    [FiberRef.CurrentLogAnnotations, new Stack.Stack(ImmutableMap())],
+  ])
+
+export function FiberRefs(
+  locals: ImmutableMap<FiberRef.AnyFiberRef, Stack.Stack<any>> = ImmutableMap(defaultFiberLocals()),
+): FiberRefs {
+  const atomic = Atomic(locals)
+  const fiberRefs: FiberRefs = {
+    locals: atomic,
+    fork: () => fork(fiberRefs),
+    *[Symbol.iterator]() {
+      for (const [key, stack] of atomic.get()) {
+        yield [key, stack.value] as const
+      }
+    },
+  }
+
+  return fiberRefs
+}
+
+export function maybeGetFiberRefStack<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
+  return (fiberRefs: FiberRefs) =>
+    fiberRefs.locals.get().get(fiberRef) as Maybe.Maybe<Stack.Stack<A>>
+}
+
+export function maybeGetFiberRefValue<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
+  return flow(
+    maybeGetFiberRefStack(fiberRef),
+    Maybe.map((s) => s.value),
+  )
+}
+
+export function setFiberRef<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>, value: A) {
+  return (fiberRefs: FiberRefs): A =>
+    fiberRefs.locals.modify((locals) => {
+      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
+
+      return [
+        value,
+        locals.set(
+          fiberRef,
+          pipe(
+            curr,
+            Maybe.match(
+              () => new Stack.Stack(value),
+              (c) => c.replace(() => value),
+            ),
+          ),
+        ),
+      ]
+    })
+}
+
+export function setFiberRefLocally<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>, value: A) {
+  return (fiberRefs: FiberRefs): A =>
+    fiberRefs.locals.modify((locals) => {
+      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
+
+      return [
+        value,
+        locals.set(
+          fiberRef,
+          pipe(
+            curr,
+            Maybe.match(
+              () => new Stack.Stack(value),
+              (c) => c.push(value),
+            ),
+          ),
+        ),
+      ]
+    })
+}
+
+export function popLocalFiberRef<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
+  return (fiberRefs: FiberRefs): Maybe.Maybe<A> =>
+    fiberRefs.locals.modify((locals) => {
+      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
+
+      if (Maybe.isNothing(curr)) {
+        return [Maybe.Nothing, locals.remove(fiberRef)]
+      }
+
+      const prev = curr.value.pop()
+
+      return [
+        pipe(
+          curr,
+          Maybe.map((c) => c.value),
+        ),
+        prev ? locals.set(fiberRef, prev) : locals.remove(fiberRef),
+      ]
+    })
+}
+
+export function deleteFiberRef<R, E, A>(fiberRef: FiberRef.FiberRef<R, E, A>) {
+  return (fiberRefs: FiberRefs): Maybe.Maybe<Stack.Stack<A>> =>
+    fiberRefs.locals.modify((locals) => {
+      const curr = maybeGetFiberRefStack(fiberRef)(fiberRefs)
+
+      return [curr, locals.remove(fiberRef)]
+    })
+}
+
+export function fork(fiberRefs: FiberRefs): FiberRefs {
+  const updated = new Map<FiberRef.AnyFiberRef, Stack.Stack<any>>()
+
+  for (const [key, stack] of fiberRefs.locals.get()) {
+    const forked = key.fork(stack.value)
+
+    if (Maybe.isJust(forked)) {
+      updated.set(
+        key,
+        stack.replace(() => forked.value),
+      )
+    }
+  }
+
+  return FiberRefs(ImmutableMap(updated))
+}
+
+export function join(first: FiberRefs, second: FiberRefs): void {
+  const updated = new Map<FiberRef.AnyFiberRef, Stack.Stack<any>>(first.locals.get())
+  const incoming = second.locals.get()
+
+  for (const [key, stack] of incoming) {
+    const current = updated.get(key)
+
+    updated.set(key, current ? current.replace((a) => key.join(a, stack.value)) : stack)
+  }
+
+  first.locals.set(ImmutableMap(updated))
+}

package/src/FiberRefs/index.ts

@@ -0,0 +1 @@
+export * from './FiberRefs.js'