@fncts/io 0.0.17 → 0.0.19

package/_src/FiberRef/unsafe.ts

@@ -5,6 +5,7 @@ import { identity } from "@fncts/base/data/function";
 import { Patch } from "@fncts/base/data/Patch";
 import { defaultScheduler } from "@fncts/io/internal/Scheduler";
 
+import { IsFatal } from "../internal/IsFatal.js";
 import { FiberRefInternal } from "./definition.js";
 
 /**
@@ -16,8 +17,9 @@ export function unsafeMakePatch<Value, Patch>(
   combine: (first: Patch, second: Patch) => Patch,
   patch: (patch: Patch) => (oldValue: Value) => Value,
   fork: Patch,
+  join: (oldValue: Value, newValue: Value) => Value = (_, newValue) => newValue,
 ): FiberRef.WithPatch<Value, Patch> {
-  return new FiberRefInternal(initial, diff, combine, patch, fork);
+  return new FiberRefInternal(initial, diff, combine, patch, fork, join);
 }
 
 /**
@@ -45,15 +47,20 @@ export function unsafeMake<A>(
     initial,
     (_, newValue) => () => newValue,
     (first, second) => (value) => second(first(value)),
-    (patch) => (value) => join(value, patch(value)),
+    (patch) => (value) => patch(value),
     fork,
+    join,
   );
 }
 
 /**
  * @tsplus static fncts.io.FiberRefOps forkScopeOverride
  */
-export const forkScopeOverride = FiberRef.unsafeMake<Maybe<FiberScope>>(Nothing(), () => Nothing());
+export const forkScopeOverride = FiberRef.unsafeMake<Maybe<FiberScope>>(
+  Nothing(),
+  () => Nothing(),
+  (parent, _) => parent,
+);
 
 /**
  * @tsplus static fncts.io.FiberRefOps currentEnvironment
@@ -84,3 +91,20 @@ export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>
  * @tsplus static fncts.io.FiberRefOps currentScheduler
  */
 export const currentScheduler = FiberRef.unsafeMake<Scheduler>(defaultScheduler);
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentSupervisor
+ */
+export const currentSupervisor = FiberRef.unsafeMake<Supervisor<any>>(Supervisor.none);
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentIsFatal
+ */
+export const currentIsFatal = FiberRef.unsafeMake<IsFatal>(IsFatal.empty);
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentReportFatal
+ */
+export const currentReportFatal = FiberRef.unsafeMake<(t: unknown) => never>((t) => {
+  throw t;
+});

package/_src/FiberRefs/api.ts

@@ -13,3 +13,19 @@ export function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>> {
 export function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs {
   return new FiberRefs(fiberRefLocals);
 }
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs forkAs
+ */
+export function forkAs(self: FiberRefs, childId: FiberId.Runtime): FiberRefs {
+  const childFiberRefLocals = self.fiberRefLocals.mapWithIndex((fiberRef, stack) => {
+    const oldValue = stack.head[1];
+    const newValue = fiberRef.patch(fiberRef.fork)(oldValue);
+    if (oldValue === newValue) {
+      return stack;
+    } else {
+      return Cons([childId, newValue], stack);
+    }
+  });
+  return FiberRefs(childFiberRefLocals);
+}

package/_src/FiberRefs/join.ts

@@ -25,7 +25,7 @@ export function join(self: FiberRefs, fiberId: FiberId.Runtime, that: FiberRefs)
         const patch = ref.diff(ancestor, childValue);
 
         const oldValue = parentStack.head[1];
-        const newValue = ref.patch(patch)(oldValue);
+        const newValue = ref.join(oldValue, ref.patch(patch)(oldValue));
 
         if (oldValue === newValue) return parentFiberRefs;
 

package/_src/IO/api/core-scope.ts

@@ -1,13 +1,13 @@
 import { ExitTag } from "@fncts/base/data/Exit";
 
 import { FiberScope } from "../../FiberScope.js";
-import { Fork, GetForkScope, IO, OverrideForkScope, Race } from "../definition.js";
+import { Fork, IO, Race } from "../definition.js";
 
 /**
  * @tsplus getter fncts.io.IO daemonChildren
  */
 export function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.defer(new OverrideForkScope(self, Just(FiberScope.global), __tsplusTrace));
+  return IO.defer(FiberRef.forkScopeOverride.locally(Just(FiberScope.global))(self));
 }
 
 /**
@@ -15,7 +15,9 @@ export function daemonChildren<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: strin
  *
  * @tsplus static fncts.io.IOOps forkScope
  */
-export const forkScope: UIO<FiberScope> = new GetForkScope(IO.succeedNow);
+export const forkScope: UIO<FiberScope> = IO.withFiberContext((fiber) =>
+  IO(fiber.unsafeGetRef(FiberRef.forkScopeOverride).getOrElse(fiber.scope)),
+);
 
 /**
  * Retrieves the scope that will be used to supervise forked effects.
@@ -23,14 +25,14 @@ export const forkScope: UIO<FiberScope> = new GetForkScope(IO.succeedNow);
  * @tsplus static fncts.io.IOOps forkScopeWith
  */
 export function forkScopeWith<R, E, A>(f: (_: FiberScope) => IO<R, E, A>, __tsplusTrace?: string) {
-  return new GetForkScope(f, __tsplusTrace);
+  return forkScope.flatMap(f);
 }
 
 export class ForkScopeRestore {
   constructor(private scope: FiberScope) {}
 
   readonly restore = <R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> =>
-    new OverrideForkScope(ma, Just(this.scope), __tsplusTrace);
+    FiberRef.forkScopeOverride.locally(Just(this.scope))(ma);
 }
 
 /**
@@ -45,8 +47,8 @@ export function forkScopeMask_<R, E, A>(
   f: (restore: ForkScopeRestore) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return IO.forkScopeWith(
-    (scope) => new OverrideForkScope(f(new ForkScopeRestore(scope)), Just(newScope), __tsplusTrace),
+  return IO.forkScopeWith((scope) =>
+    FiberRef.forkScopeOverride.locally(Just(newScope))(f(new ForkScopeRestore(scope))),
   );
 }
 
@@ -103,7 +105,7 @@ export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
  * @tsplus static fncts.io.IOOps transplant
  */
 export function transplant<R, E, A>(f: (_: Grafter) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return forkScopeWith((scope) => f((e) => new OverrideForkScope(e, Just(scope))));
+  return forkScopeWith((scope) => f((e) => FiberRef.forkScopeOverride.locally(Just(scope))(e)));
 }
 
 /**
@@ -124,7 +126,7 @@ export function forkDaemon<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): UR
  * @tsplus fluent fncts.io.IO overrideForkScope
  */
 export function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope, __tsplusTrace?: string): IO<R, E, A> {
-  return new OverrideForkScope(ma, Just(scope), __tsplusTrace);
+  return FiberRef.forkScopeOverride.locally(Just(scope))(ma);
 }
 
 /**
@@ -134,5 +136,5 @@ export function overrideForkScope_<R, E, A>(ma: IO<R, E, A>, scope: FiberScope,
  * @tsplus getter fncts.io.IO defaultForkScope
  */
 export function defaultForkScope<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new OverrideForkScope(ma, Nothing(), __tsplusTrace);
+  return FiberRef.forkScopeOverride.locally(Nothing())(ma);
 }

package/_src/IO/api/interrupt.ts

@@ -1,5 +1,3 @@
-import { SetInterrupt } from "../definition.js";
-
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
  *
@@ -30,7 +28,14 @@ export function setInterruptStatus_<R, E, A>(
   flag: InterruptStatus,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new SetInterrupt(self, flag, __tsplusTrace);
+  return IO.withFiberContext((fiber) => {
+    const b = flag.toBoolean;
+    if (fiber.unsafeIsInterruptible !== b) {
+      fiber.interruptStatus.push(b);
+      fiber.unsafeRestoreInterruptStatus();
+    }
+    return self;
+  });
 }
 
 /**

package/_src/IO/api/supervised.ts

@@ -0,0 +1,14 @@
+/**
+ *
+ * Returns an IO with the behavior of this one, but where all child
+ * fibers forked in the effect are reported to the specified supervisor.
+ *
+ * @tsplus fluent fncts.io.IO supervised
+ */
+export function supervised_<R, E, A>(
+  fa: IO<R, E, A>,
+  supervisor: Supervisor<any>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return FiberRef.currentSupervisor.locally(supervisor)(fa);
+}

package/_src/IO/api.ts

@@ -1,28 +1,24 @@
+import type { FiberStatus } from "../FiberStatus.js";
 import type * as P from "@fncts/base/typeclass";
 import type { _E, _R } from "@fncts/base/types";
 import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
 import type { Canceler } from "@fncts/io/IO/definition";
 
 import { identity, pipe, tuple } from "@fncts/base/data/function";
+import { Stateful } from "@fncts/io/IO/definition";
 import {
   Async,
   Chain,
   Defer,
   DeferWith,
-  Ensuring,
   Fail,
-  FiberRefModifyAll,
   Fork,
-  GetDescriptor,
-  GetInterrupt,
   IO,
   IOError,
   Logged,
   Match,
-  SetRuntimeConfig,
   Succeed,
   SucceedNow,
-  Supervise,
   Yield,
 } from "@fncts/io/IO/definition";
 
@@ -358,7 +354,7 @@ export function checkInterruptible<R, E, A>(
   f: (i: InterruptStatus) => IO<R, E, A>,
   __tsplusTrace?: string,
 ): IO<R, E, A> {
-  return new GetInterrupt(f, __tsplusTrace);
+  return IO.withFiberContext((fiber) => f(InterruptStatus.fromBoolean(fiber.unsafeIsInterruptible)));
 }
 
 /**
@@ -515,7 +511,7 @@ export const descriptor = descriptorWith(IO.succeedNow);
  * @tsplus static fncts.io.IOOps descriptorWith
  */
 export function descriptorWith<R, E, A>(f: (d: FiberDescriptor) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return new GetDescriptor(f, __tsplusTrace);
+  return IO.withFiberContext((fiber) => f(fiber.unsafeGetDescriptor()));
 }
 
 /**
@@ -535,7 +531,10 @@ export function ensuring_<R, E, A, R1>(
   finalizer: IO<R1, never, any>,
   __tsplusTrace?: string,
 ): IO<R | R1, E, A> {
-  return new Ensuring(self, finalizer, __tsplusTrace);
+  return IO.withFiberContext((fiber) => {
+    fiber.unsafeAddFinalizer(finalizer);
+    return self;
+  });
 }
 
 /**
@@ -1801,7 +1800,7 @@ export function sandboxWith_<R, E, A, E1>(
  * @tsplus static fncts.io.IOOps setRuntimeConfig
  */
 export function setRuntimeConfig(runtimeConfig: Lazy<RuntimeConfig>, __tsplusTrace?: string): UIO<void> {
-  return IO.defer(new SetRuntimeConfig(runtimeConfig(), __tsplusTrace));
+  return IO.withFiberContext((fiber) => IO((fiber.runtimeConfig = runtimeConfig())));
 }
 
 /**
@@ -1839,21 +1838,6 @@ export function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A> {
   return new Succeed(effect, __tsplusTrace);
 }
 
-/**
- *
- * Returns an IO with the behavior of this one, but where all child
- * fibers forked in the effect are reported to the specified supervisor.
- *
- * @tsplus fluent fncts.io.IO supervised
- */
-export function supervised_<R, E, A>(
-  fa: IO<R, E, A>,
-  supervisor: Supervisor<any>,
-  __tsplusTrace?: string,
-): IO<R, E, A> {
-  return new Supervise(fa, supervisor);
-}
-
 /**
  * @tsplus fluent fncts.io.IO summarized
  */
@@ -2051,7 +2035,22 @@ export function updateFiberRefs(
   f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => FiberRefs,
   __tsplusTrace?: string,
 ): UIO<void> {
-  return new FiberRefModifyAll((fiberId, fiberRefs) => [undefined, f(fiberId, fiberRefs)], __tsplusTrace);
+  return IO.withFiberContext((fiber) =>
+    IO(() => {
+      const newFiberRefs   = f(fiber.fiberId, fiber.fiberRefs);
+      fiber.fiberRefLocals = newFiberRefs.fiberRefLocals;
+    }),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.IOOps withFiberContext
+ */
+export function withFiberContext<R, E, A>(
+  onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return new Stateful(onState, __tsplusTrace);
 }
 
 /**

package/_src/IO/definition.ts

@@ -1,3 +1,4 @@
+import type { FiberStatus } from "../FiberStatus.js";
 import type { Trace as Trace_ } from "@fncts/base/data/Trace";
 import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
 
@@ -7,7 +8,7 @@ export type IOTypeId = typeof IOTypeId;
 export interface IOF extends HKT {
   type: IO<this["R"], this["E"], this["A"]>;
   variance: {
-    R: "-";
+    R: "+";
     E: "+";
     A: "+";
   };
@@ -66,22 +67,9 @@ export const enum IOTag {
   Fail = "Fail",
   Yield = "Yield",
   Race = "Race",
-  SetInterrupt = "SetInterrupt",
-  GetInterrupt = "GetInterrupt",
-  GetDescriptor = "GetDescriptor",
-  Supervise = "Supervise",
-  FiberRefModify = "FiberRefModify",
-  FiberRefLocally = "FiberRefLocally",
-  FiberRefDelete = "FiberRefDelete",
-  FiberRefWith = "FiberRefWith",
-  FiberRefModifyAll = "FiberRefModifyAll",
-  GetForkScope = "GetForkScope",
-  OverrideForkScope = "OverrideForkScope",
   Trace = "Trace",
-  GetRuntimeConfig = "GetRuntimeConfig",
-  Ensuring = "Ensuring",
   Logged = "Logged",
-  SetRuntimeConfig = "SetRuntimeConfig",
+  Stateful = "Stateful",
 }
 
 export function isIO(u: unknown): u is IO<any, any, any> {
@@ -236,134 +224,16 @@ export class Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3> extends IO<R | R1
   }
 }
 
-/**
- * @internal
- */
-export class SetInterrupt<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.SetInterrupt;
-
-  constructor(readonly io: IO<R, E, A>, readonly flag: InterruptStatus, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class GetInterrupt<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetInterrupt;
-
-  constructor(readonly f: (_: InterruptStatus) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class GetDescriptor<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetDescriptor;
-
-  constructor(readonly f: (_: FiberDescriptor) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class Supervise<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.Supervise;
-
-  constructor(readonly io: IO<R, E, A>, readonly supervisor: Supervisor<any>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class FiberRefModify<A, B> extends IO<never, never, B> {
-  readonly _tag = IOTag.FiberRefModify;
-
-  constructor(readonly fiberRef: FiberRef<unknown>, readonly f: (a: A) => readonly [B, A], readonly trace?: string) {
-    super();
-  }
-}
-
-export class FiberRefLocally<V, R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.FiberRefLocally;
+export class Stateful<R, E, A> extends IO<R, E, A> {
+  readonly _tag = IOTag.Stateful;
   constructor(
-    readonly localValue: V,
-    readonly fiberRef: FiberRef<V>,
-    readonly io: IO<R, E, A>,
+    readonly onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>,
     readonly trace?: string,
   ) {
     super();
   }
 }
 
-export class FiberRefDelete extends IO<never, never, void> {
-  readonly _tag = IOTag.FiberRefDelete;
-  constructor(readonly fiberRef: FiberRef<unknown>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class FiberRefWith<A, P, R, E, B> extends IO<R, E, B> {
-  readonly _tag = IOTag.FiberRefWith;
-  constructor(readonly fiberRef: FiberRef<A>, readonly f: (a: A) => IO<R, E, B>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class FiberRefModifyAll<A> extends IO<never, never, A> {
-  readonly _tag = IOTag.FiberRefModifyAll;
-  constructor(
-    readonly f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => readonly [A, FiberRefs],
-    readonly trace?: string,
-  ) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class GetForkScope<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetForkScope;
-
-  constructor(readonly f: (_: FiberScope) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-/**
- * @internal
- */
-export class OverrideForkScope<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.OverrideForkScope;
-
-  constructor(readonly io: IO<R, E, A>, readonly forkScope: Maybe<FiberScope>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class GetRuntimeConfig<R, E, A> extends IO<R, E, A> {
-  readonly _tag = IOTag.GetRuntimeConfig;
-
-  constructor(readonly f: (_: RuntimeConfig) => IO<R, E, A>, readonly trace?: string) {
-    super();
-  }
-}
-
-export class Ensuring<R, E, A, R1> extends IO<R | R1, E, A> {
-  readonly _tag = IOTag.Ensuring;
-  constructor(readonly io: IO<R, E, A>, readonly finalizer: IO<R1, never, any>, readonly trace?: string) {
-    super();
-  }
-}
-
 export class Logged extends IO<never, never, void> {
   readonly _tag = IOTag.Logged;
   constructor(
@@ -378,13 +248,6 @@ export class Logged extends IO<never, never, void> {
   }
 }
 
-export class SetRuntimeConfig extends IO<never, never, void> {
-  readonly _tag = IOTag.SetRuntimeConfig;
-  constructor(readonly runtimeConfig: RuntimeConfig, readonly trace?: string) {
-    super();
-  }
-}
-
 export type Instruction =
   | Chain<any, any, any, any, any, any>
   | SucceedNow<any>
@@ -393,27 +256,14 @@ export type Instruction =
   | Async<any, any, any, any>
   | Match<any, any, any, any, any, any, any, any, any>
   | Fork<any, any, any>
-  | SetInterrupt<any, any, any>
-  | GetInterrupt<any, any, any>
   | Fail<any>
-  | GetDescriptor<any, any, any>
   | Yield
   | Defer<any, any, any>
   | DeferWith<any, any, any>
-  | FiberRefModify<any, any>
-  | FiberRefLocally<any, any, any, any>
-  | FiberRefDelete
-  | FiberRefWith<any, any, any, any, any>
-  | FiberRefModifyAll<any>
+  | Stateful<any, any, any>
   | Race<any, any, any, any, any, any, any, any, any, any, any, any>
-  | Supervise<any, any, any>
-  | GetForkScope<any, any, any>
-  | OverrideForkScope<any, any, any>
   | Trace
-  | GetRuntimeConfig<any, any, any>
-  | Ensuring<any, any, any, any>
-  | Logged
-  | SetRuntimeConfig;
+  | Logged;
 
 /**
  * @tsplus macro identity

package/_src/IO/runtime.ts

@@ -17,11 +17,9 @@ export class Runtime<R> {
       fiberId,
       this.runtimeConfig,
       Stack.single(InterruptStatus.interruptible.toBoolean),
-      new AtomicReference(
-        HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>(
-          [FiberRef.currentEnvironment, Cons([fiberId, this.environment])],
-          [IOEnv.services, Cons([fiberId, IOEnv.environment])],
-        ),
+      HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>(
+        [FiberRef.currentEnvironment, Cons([fiberId, this.environment])],
+        [IOEnv.services, Cons([fiberId, IOEnv.environment])],
       ),
       children,
     );
@@ -71,12 +69,10 @@ export class Runtime<R> {
       fiberId,
       this.runtimeConfig,
       Stack.single(InterruptStatus.interruptible.toBoolean),
-      new AtomicReference(
-        HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>(
-          [FiberRef.currentEnvironment, Cons([fiberId, this.environment])],
-          [IOEnv.services, Cons([fiberId, IOEnv.environment])],
-          [FiberRef.currentScheduler, Cons([fiberId, scheduler])],
-        ),
+      HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>(
+        [FiberRef.currentEnvironment, Cons([fiberId, this.environment])],
+        [IOEnv.services, Cons([fiberId, IOEnv.environment])],
+        [FiberRef.currentScheduler, Cons([fiberId, scheduler])],
       ),
       children,
     );

package/_src/IO.ts

@@ -46,6 +46,7 @@ export * from "./IO/api/scopeWith.js";
 export * from "./IO/api/sequenceT.js";
 export * from "./IO/api/sleep.js";
 export * from "./IO/api/stateful.js";
+export * from "./IO/api/supervised.js";
 export * from "./IO/api/timeout.js";
 export * from "./IO/api/withChildren.js";
 export * from "./IO/api/withEarlyRelease.js";

package/_src/Reloadable/api.ts

@@ -0,0 +1,28 @@
+import type { Reloadable } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.ReloadableOps get
+ */
+export function get<Service>(
+  /** @tsplus auto */ tag: Tag<Reloadable<Service>>,
+): IO<Reloadable<Service>, unknown, Service> {
+  return IO.serviceWithIO((service) => service.get, tag);
+}
+
+/**
+ * @tsplus static fncts.io.ReloadableOps reload
+ */
+export function reload<Service>(
+  /** @tsplua auto */ tag: Tag<Reloadable<Service>>,
+): IO<Reloadable<Service>, unknown, void> {
+  return IO.serviceWithIO((service) => service.reload, tag);
+}
+
+/**
+ * @tsplus static fncts.io.ReloadableOps reloadFork
+ */
+export function reloadFork<Service>(
+  /** @tsplus auto */ tag: Tag<Reloadable<Service>>,
+): IO<Reloadable<Service>, never, void> {
+  return IO.serviceWithIO((service) => service.reloadFork, tag);
+}

package/_src/Reloadable/constructors.ts

@@ -0,0 +1,60 @@
+import { Reloadable } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.ReloadableOps auto
+ */
+export function auto<In, E, Out, Env>(
+  layer: Layer<In, E, Out>,
+  tag: Tag<Out>,
+  schedule: Schedule<Env, any, any>,
+  /** @tsplus auto */ reloadableTag: Tag<Reloadable<Out>>
+): Layer<In | Env, E, Reloadable<Out>> {
+  return Layer.scoped(
+    Do((Δ) => {
+      const env        = Δ(Reloadable.manual(layer, tag, reloadableTag).build);
+      const reloadable = env.unsafeGet(reloadableTag);
+      Δ(IO.acquireRelease(reloadable.reload.schedule(schedule).forkDaemon, (fiber) => fiber.interrupt));
+      return reloadable;
+    }),
+    reloadableTag,
+  );
+}
+
+/**
+ * @tsplus static fncts.io.ReloadableOps autoFromConfig
+ */
+export function autoFromConfig<In, E, Out, Env>(
+  layer: Layer<In, E, Out>,
+  tag: Tag<Out>,
+  scheduleFromConfig: (env: Environment<In>) => Schedule<Env, any, any>,
+  /** @tsplus auto */ reloadableTag: Tag<Reloadable<Out>>
+): Layer<In | Env, E, Reloadable<Out>> {
+  return Layer.scoped(
+    Do((Δ) => {
+      const inp      = Δ(IO.environment<In>());
+      const schedule = scheduleFromConfig(inp);
+      const env      = Δ(Reloadable.auto(layer, tag, schedule).build);
+      return env.unsafeGet(reloadableTag);
+    }),
+    reloadableTag,
+  );
+}
+
+/**
+ * @tsplus static fncts.io.ReloadableOps manual
+ */
+export function manual<In, E, Out>(
+  layer: Layer<In, E, Out>,
+  tag: Tag<Out>,
+  /** @tsplus auto */ reloadableTag: Tag<Reloadable<Out>>,
+): Layer<In, E, Reloadable<Out>> {
+  return Layer.scoped(
+    Do((Δ) => {
+      const inp    = Δ(IO.environment<In>());
+      const ref    = Δ(ScopedRef.fromAcquire(layer.build.map((env) => env.unsafeGet(tag))));
+      const reload = ref.set(layer.build.map((env) => env.unsafeGet(tag))).provideEnvironment(inp);
+      return new Reloadable(ref, reload);
+    }),
+    reloadableTag,
+  );
+}