@fncts/io 0.0.12 → 0.0.15

package/_src/Channel/definition.ts

@@ -26,13 +26,13 @@ export const enum ChannelTag {
  * @tsplus companion fncts.io.ChannelOps
  */
 export abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
-  readonly _Env!: (_: Env) => void;
-  readonly _InErr!: (_: InErr) => void;
-  readonly _InElem!: (_: InElem) => void;
-  readonly _InDone!: (_: InDone) => void;
-  readonly _OutErr!: () => OutErr;
-  readonly _OutElem!: () => OutElem;
-  readonly _OutDone!: () => OutDone;
+  declare _Env: () => Env;
+  declare _InErr: (_: InErr) => void;
+  declare _InElem: (_: InElem) => void;
+  declare _InDone: (_: InDone) => void;
+  declare _OutErr: () => OutErr;
+  declare _OutElem: () => OutElem;
+  declare _OutDone: () => OutDone;
 }
 
 /**
@@ -41,19 +41,19 @@ export abstract class Channel<Env, InErr, InElem, InDone, OutErr, OutElem, OutDo
 export function unifyChannel<X extends Channel<any, any, any, any, any, any, any>>(
   _: X,
 ): Channel<
-  [X] extends [Channel<infer Env, any, any, any, any, any, any>] ? Env : never,
-  [X] extends [Channel<any, infer InErr, any, any, any, any, any>] ? InErr : never,
-  [X] extends [Channel<any, any, infer InElem, any, any, any, any>] ? InElem : never,
-  [X] extends [Channel<any, any, any, infer InDone, any, any, any>] ? InDone : never,
-  [X] extends [Channel<any, any, any, any, infer OutErr, any, any>] ? OutErr : never,
-  [X] extends [Channel<any, any, any, any, any, infer OutElem, any>] ? OutElem : never,
-  [X] extends [Channel<any, any, any, any, any, any, infer OutDone>] ? OutDone : never
+  [X] extends [{ _Env: () => infer Env }] ? Env : never,
+  [X] extends [{ _InErr: (_: infer InErr) => void }] ? InErr : never,
+  [X] extends [{ _InElem: (_: infer InElem) => void }] ? InElem : never,
+  [X] extends [{ _InDone: (_: infer InDone) => void }] ? InDone : never,
+  [X] extends [{ _OutErr: () => infer OutErr }] ? OutErr : never,
+  [X] extends [{ _OutElem: () => infer OutElem }] ? OutElem : never,
+  [X] extends [{ _OutDone: () => infer OutDone }] ? OutDone : never
 > {
   return _;
 }
 
 export abstract class Continuation<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone, OutDone2> {
-  readonly _Env!: (_: Env) => void;
+  readonly _Env!: () => Env;
   readonly _InErr!: (_: InErr) => void;
   readonly _InElem!: (_: InElem) => void;
   readonly _InDone!: (_: InDone) => void;
@@ -170,14 +170,14 @@ export class Read<Env, InErr, InElem, InDone, OutErr, OutErr2, OutElem, OutDone,
   }
 }
 
-export class Done<OutDone> extends Channel<unknown, unknown, unknown, unknown, never, never, OutDone> {
+export class Done<OutDone> extends Channel<never, unknown, unknown, unknown, never, never, OutDone> {
   readonly _tag = ChannelTag.Done;
   constructor(readonly terminal: () => OutDone) {
     super();
   }
 }
 
-export class Fail<OutErr> extends Channel<unknown, unknown, unknown, unknown, OutErr, never, never> {
+export class Fail<OutErr> extends Channel<never, unknown, unknown, unknown, OutErr, never, never> {
   readonly _tag = ChannelTag.Halt;
   constructor(readonly cause: () => Cause<OutErr>) {
     super();
@@ -257,7 +257,7 @@ export class BracketOut<R, E, Z, OutDone> extends Channel<R, unknown, unknown, u
 }
 
 export class Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> extends Channel<
-  unknown,
+  never,
   InErr,
   InElem,
   InDone,
@@ -274,7 +274,7 @@ export class Provide<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> exten
   }
 }
 
-export class Emit<OutElem, OutDone> extends Channel<unknown, unknown, unknown, unknown, never, OutElem, OutDone> {
+export class Emit<OutElem, OutDone> extends Channel<never, unknown, unknown, unknown, never, OutElem, OutDone> {
   readonly _tag = ChannelTag.Emit;
   constructor(readonly out: () => OutElem) {
     super();

package/_src/Channel/internal/MergeDecision.ts

@@ -12,7 +12,7 @@ export type MergeDecisionTypeId = typeof MergeDecisionTypeId;
  */
 export abstract class MergeDecision<R, E0, Z0, E, Z> {
   readonly _typeId: MergeDecisionTypeId = MergeDecisionTypeId;
-  readonly _R!: (_: R) => void;
+  readonly _R!: () => R;
   readonly _E0!: (_: E0) => void;
   readonly _Z0!: (_: Z0) => void;
   readonly _E!: () => E;

package/_src/Clock/live.ts

@@ -2,7 +2,7 @@ class LiveClock extends Clock {
   currentTime: UIO<number> = IO.succeed(Date.now());
 
   sleep(duration: Lazy<Duration>, __tsplusTrace?: string): UIO<void> {
-    return IO.asyncInterrupt<unknown, never, void>((k) => {
+    return IO.asyncInterrupt<never, never, void>((k) => {
       const handle = setTimeout(() => {
         k(IO.unit);
       }, duration().milliseconds);

package/_src/Console/api.ts

@@ -8,6 +8,6 @@ export function show(...data: unknown[]): UIO<void> {
 /**
  * @tsplus static fncts.io.ConsoleOps print
  */
-export function print(line: string): UIO<void> {
+export function print(line: string, __tsplusTrace?: string): UIO<void> {
   return IO.consoleWith((console) => console.print(line));
 }

package/_src/Fiber/FiberContext.ts

@@ -34,7 +34,7 @@ export class TracedCont {
 
 export class Finalizer {
   readonly _tag = "Finalizer";
-  constructor(readonly finalizer: UIO<any>, readonly apply: ErasedCont, readonly trace?: string) {}
+  constructor(readonly finalizer: IO<any, never, any>, readonly apply: ErasedCont, readonly trace?: string) {}
 }
 
 export type Frame =
@@ -533,7 +533,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
   }
 
   unsafeRunLater(i0: Instruction) {
-    defaultScheduler(() => {
+    this.unsafeGetRef(FiberRef.currentScheduler).scheduleTask(() => {
       this.nextIO = i0;
       this.runUntil(this.runtimeConfig.yieldOpCount);
     });
@@ -569,7 +569,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     this.fiberRefLocals.set(this.fiberRefLocals.get.remove(ref));
   }
 
-  private unsafePoll() {
+  unsafePoll() {
     switch (this.state._tag) {
       case "Executing": {
         return Nothing();
@@ -592,7 +592,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     }
   });
 
-  private unsafeAddFinalizer(finalizer: UIO<any>): void {
+  private unsafeAddFinalizer(finalizer: IO<any, never, any>): void {
     this.stack.push(
       new Finalizer(finalizer, (v) => {
         this.unsafeDisableInterruption();
@@ -929,7 +929,9 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     const childIO = !parentScope.unsafeAdd(childContext) ? IO.interruptAs(parentScope.fiberId) : io;
 
     childContext.nextIO = concrete(childIO);
-    defaultScheduler(() => childContext.runUntil(this.runtimeConfig.yieldOpCount));
+    this.unsafeGetRef(FiberRef.currentScheduler).scheduleTask(() =>
+      childContext.runUntil(this.runtimeConfig.yieldOpCount),
+    );
 
     return childContext;
   }
@@ -968,12 +970,12 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
 
   private unsafeRace<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(
     race: Race<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>,
-  ): IO<R & R1 & R2 & R3, E2 | E3, A2 | A3> {
+  ): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3> {
     const raceIndicator = new AtomicReference(true);
     const left          = this.unsafeFork(concrete(race.left), Nothing(), race.trace);
     const right         = this.unsafeFork(concrete(race.right), Nothing(), race.trace);
 
-    return IO.async<R & R1 & R2 & R3, E2 | E3, A2 | A3>((cb) => {
+    return IO.async<R | R1 | R2 | R3, E2 | E3, A2 | A3>((cb) => {
       const leftRegister = left.unsafeAddObserver(() => {
         this.unsafeCompleteRace(left, right, race.leftWins, raceIndicator, cb);
       });
@@ -995,7 +997,7 @@ export class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equata
     loser: Fiber<any, any>,
     cont: (fiber0: Fiber<any, any>, fiber1: Fiber<any, any>) => Erased,
     ab: AtomicReference<boolean>,
-    cb: (_: IO<R & R1 & R2 & R3, E2 | E3, A2 | A3>) => void,
+    cb: (_: IO<R | R1 | R2 | R3, E2 | E3, A2 | A3>) => void,
   ): void {
     if (ab.compareAndSet(true, false)) {
       cb(cont(winner, loser));

package/_src/Fiber/api/await.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber await
  */
-export function wait<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>> {
+export function wait<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<Exit<E, A>> {
   fiber.concrete();
   return fiber.await;
 }

package/_src/Fiber/api/awaitAll.ts

@@ -3,6 +3,6 @@
  *
  * @tsplus static fncts.io.FiberOps awaitAll
  */
-export function awaitAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, never, Exit<E, Conc<A>>> {
+export function awaitAll<E, A>(as: Iterable<Fiber<E, A>>, __tsplusTrace?: string): IO<never, never, Exit<E, Conc<A>>> {
   return IO.foreachC(as, (f) => f.await.flatMap(IO.fromExitNow)).result;
 }

package/_src/Fiber/api/children.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber children
  */
-export function children<E, A>(self: Fiber<E, A>): UIO<Conc<Fiber.Runtime<any, any>>> {
+export function children<E, A>(self: Fiber<E, A>, __tsplusTrace?: string): UIO<Conc<Fiber.Runtime<any, any>>> {
   self.concrete();
   return self.children;
 }

package/_src/Fiber/api/collectAll.ts

@@ -6,7 +6,10 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
  *
  * @tsplus static fncts.io.FiberOps sequenceIterable
  */
-export function sequenceIterable<E, A>(fibers: Iterable<Fiber<E, A>>): Fiber.Synthetic<E, Conc<A>> {
+export function sequenceIterable<E, A>(
+  fibers: Iterable<Fiber<E, A>>,
+  __tsplusTrace?: string,
+): Fiber.Synthetic<E, Conc<A>> {
   return new SyntheticFiber(
     fibers.foldLeft(FiberId.none as FiberId, (b, a) => b.combine(a.id)),
     Fiber.awaitAll(fibers),

package/_src/Fiber/api/evalOn.ts

@@ -1,7 +1,12 @@
 /**
  * @tsplus fluent fncts.io.Fiber evalOn
  */
-export function evalOn_<E, A>(fiber: Fiber<E, A>, effect: UIO<any>, orElse: UIO<any>): UIO<void> {
+export function evalOn_<E, A>(
+  fiber: Fiber<E, A>,
+  effect: UIO<any>,
+  orElse: UIO<any>,
+  __tsplusTrace?: string,
+): UIO<void> {
   fiber.concrete();
   switch (fiber._tag) {
     case "RuntimeFiber":

package/_src/Fiber/api/evalOnIO.ts

@@ -8,7 +8,8 @@ export function evalOnIO_<E, A, R1, E1, B, R2, E2, C>(
   fiber: Fiber<E, A>,
   effect: IO<R1, E1, B>,
   orElse: IO<R2, E2, C>,
-): IO<R1 & R2, E1 | E2, B | C> {
+  __tsplusTrace?: string,
+): IO<R1 | R2, E1 | E2, B | C> {
   return Do((Δ) => {
     const r = Δ(IO.environment<R1 & R2>());
     const f = Δ(Future.make<E1 | E2, B | C>());

package/_src/Fiber/api/fromIO.ts

@@ -3,6 +3,6 @@
  *
  * @tsplus static fncts.io.FiberOps fromIO
  */
-export function fromIO<E, A>(effect: FIO<E, A>): UIO<Fiber<E, A>> {
+export function fromIO<E, A>(effect: FIO<E, A>, __tsplusTrace?: string): UIO<Fiber<E, A>> {
   return effect.result.map((exit) => Fiber.done(exit));
 }

package/_src/Fiber/api/id.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber id
  */
-export function id<E, A>(self: Fiber<E, A>): FiberId {
+export function id<E, A>(self: Fiber<E, A>, __tsplusTrace?: string): FiberId {
   self.concrete();
   return self.id;
 }

package/_src/Fiber/api/inheritRefs.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber inheritRefs
  */
-export function inheritRefs<E, A>(fiber: Fiber<E, A>): UIO<void> {
+export function inheritRefs<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<void> {
   fiber.concrete();
   return fiber.inheritRefs;
 }

package/_src/Fiber/api/interrupt.ts

@@ -5,7 +5,7 @@
  *
  * @tsplus getter fncts.io.Fiber interrupt
  */
-export function interrupt<E, A>(fiber: Fiber<E, A>): UIO<Exit<E, A>> {
+export function interrupt<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<Exit<E, A>> {
   fiber.concrete();
   return IO.fiberId.flatMap((id) => fiber.interruptAs(id));
 }

package/_src/Fiber/api/interruptAll.ts

@@ -3,7 +3,7 @@
  *
  * @tsplus static fncts.io.FiberOps interruptAllAs
  */
-export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId): UIO<void> {
+export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void> {
   return fs.foldLeft(IO.unit, (io, f) => io.flatMap(() => f.interruptAs(id).asUnit));
 }
 
@@ -12,6 +12,6 @@ export function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId): UIO
  *
  * @tsplus static fncts.io.FiberOps interruptAll
  */
-export function interruptAll(fs: Iterable<Fiber<any, any>>): UIO<void> {
+export function interruptAll(fs: Iterable<Fiber<any, any>>, __tsplusTrace?: string): UIO<void> {
   return IO.fiberId.flatMap((id) => Fiber.interruptAllAs(fs, id));
 }

package/_src/Fiber/api/interruptAs.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.io.Fiber interruptAs
  */
-export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<Exit<E, A>> {
+export function interruptAs<E, A>(self: Fiber<E, A>, fiberId: FiberId, __tsplusTrace?: string): UIO<Exit<E, A>> {
   self.concrete();
   return self.interruptAs(fiberId);
 }

package/_src/Fiber/api/join.ts

@@ -7,7 +7,7 @@
  *
  * @tsplus getter fncts.io.Fiber join
  */
-export function join<E, A>(fiber: Fiber<E, A>): FIO<E, A> {
+export function join<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): FIO<E, A> {
   fiber.concrete();
   return fiber.await.flatMap(IO.fromExitNow).tap(() => fiber.inheritRefs);
 }

package/_src/Fiber/api/joinAll.ts

@@ -5,7 +5,7 @@
  *
  * @tsplus static fncts.io.FiberOps joinAll
  */
-export function joinAll<E, A>(as: Iterable<Fiber<E, A>>): IO<unknown, E, Conc<A>> {
+export function joinAll<E, A>(as: Iterable<Fiber<E, A>>, __tsplusTrace?: string): IO<never, E, Conc<A>> {
   return Fiber.awaitAll(as)
     .flatMap(IO.fromExitNow)
     .tap(() => IO.foreach(as, (f) => f.inheritRefs));

package/_src/Fiber/api/mapFiber.ts

@@ -4,6 +4,10 @@
  *
  * @tsplus fluent fncts.io.Fiber mapFiber
  */
-export function mapFiber_<A, E, E1, A1>(fiber: Fiber<E, A>, f: (a: A) => Fiber<E1, A1>): UIO<Fiber<E | E1, A1>> {
+export function mapFiber_<A, E, E1, A1>(
+  fiber: Fiber<E, A>,
+  f: (a: A) => Fiber<E1, A1>,
+  __tsplusTrace?: string,
+): UIO<Fiber<E | E1, A1>> {
   return fiber.await.map((exit) => exit.match(Fiber.failCause, f));
 }

package/_src/Fiber/api/mapIO.ts

@@ -5,7 +5,11 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
  *
  * @tsplus fluent fncts.io.Fiber mapIO
  */
-export function mapIO_<E, E1, A, B>(fiber: Fiber<E, A>, f: (a: A) => FIO<E1, B>): Fiber<E | E1, B> {
+export function mapIO_<E, E1, A, B>(
+  fiber: Fiber<E, A>,
+  f: (a: A) => FIO<E1, B>,
+  __tsplusTrace?: string,
+): Fiber<E | E1, B> {
   return new SyntheticFiber(
     fiber.id,
     fiber.await.flatMap((_) => _.foreachIO(f)),
@@ -26,6 +30,6 @@ export function mapIO_<E, E1, A, B>(fiber: Fiber<E, A>, f: (a: A) => FIO<E1, B>)
  *
  * @tsplus fluent fncts.io.Fiber map
  */
-export function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B): Fiber<E, B> {
+export function map_<E, A, B>(fa: Fiber<E, A>, f: (a: A) => B, __tsplusTrace?: string): Fiber<E, B> {
   return fa.mapIO((a) => IO.succeedNow(f(a)));
 }

package/_src/Fiber/api/poll.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber poll
  */
-export function poll<E, A>(self: Fiber<E, A>): UIO<Maybe<Exit<E, A>>> {
+export function poll<E, A>(self: Fiber<E, A>, __tsplusTrace?: string): UIO<Maybe<Exit<E, A>>> {
   self.concrete();
   return self.poll;
 }

package/_src/Fiber/api/zipWith.ts

@@ -11,6 +11,7 @@ export function zipWith_<E, A, E1, B, C>(
   self: Fiber<E, A>,
   that: Fiber<E1, B>,
   f: (a: A, b: B) => C,
+  __tsplusTrace?: string,
 ): Fiber<E | E1, C> {
   return new SyntheticFiber(
     self.id,

package/_src/Fiber/constructors.ts

@@ -3,7 +3,7 @@ import { SyntheticFiber } from "@fncts/io/Fiber/definition";
 /**
  * @tsplus static fncts.io.FiberOps done
  */
-export function done<E, A>(exit: Exit<E, A>): Fiber<E, A> {
+export function done<E, A>(exit: Exit<E, A>, __tsplusTrace?: string): Fiber<E, A> {
   return new SyntheticFiber(
     FiberId.none,
     IO.succeedNow(exit),
@@ -17,27 +17,27 @@ export function done<E, A>(exit: Exit<E, A>): Fiber<E, A> {
 /**
  * @tsplus static fncts.io.FiberOps fail
  */
-export function fail<E>(e: E): Fiber<E, never> {
+export function fail<E>(e: E, __tsplusTrace?: string): Fiber<E, never> {
   return done(Exit.fail(e));
 }
 
 /**
  * @tsplus static fncts.io.FiberOps failCause
  */
-export function failCause<E>(cause: Cause<E>): Fiber<E, never> {
+export function failCause<E>(cause: Cause<E>, __tsplusTrace?: string): Fiber<E, never> {
   return done(Exit.failCause(cause));
 }
 
 /**
  * @tsplus static fncts.io.FiberOps interruptAs
  */
-export function interrupted(id: FiberId): Fiber<never, never> {
+export function interrupted(id: FiberId, __tsplusTrace?: string): Fiber<never, never> {
   return done(Exit.interrupt(id));
 }
 
 /**
  * @tsplus static fncts.io.FiberOps succeed
  */
-export function succeed<A>(a: A): Fiber<never, A> {
+export function succeed<A>(a: A, __tsplusTrace?: string): Fiber<never, A> {
   return done(Exit.succeed(a));
 }

package/_src/Fiber/definition.ts

@@ -80,7 +80,7 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
   readonly evalOnIO: <R1, E1, B, R2, E2, C>(
     effect: IO<R1, E1, B>,
     orElse: IO<R2, E2, C>,
-  ) => IO<R1 & R2, E1 | E2, B | C>;
+  ) => IO<R1 | R2, E1 | E2, B | C>;
 
   /**
    * The status of the fiber.

package/_src/FiberRef/api/locallyScoped.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScoped
  */
-export function locallyScoped_<A>(ref: FiberRef<A>, a: A): IO<Has<Scope>, never, void> {
+export function locallyScoped_<A>(ref: FiberRef<A>, a: A, __tsplusTrace?: string): IO<Scope, never, void> {
   return IO.acquireRelease(
     ref.get.flatMap((old) => ref.set(a).as(old)),
     (a) => ref.set(a),

package/_src/FiberRef/api/locallyScopedWith.ts

@@ -1,6 +1,10 @@
 /**
  * @tsplus fluent fncts.io.FiberRef locallyScopedWith
  */
-export function locallyScopedWith<A>(self: FiberRef<A>, f: (a: A) => A): IO<Has<Scope>, never, void> {
+export function locallyScopedWith<A>(
+  self: FiberRef<A>,
+  f: (a: A) => A,
+  __tsplusTrace?: string,
+): IO<Scope, never, void> {
   return self.getWith((a) => self.locallyScoped(f(a)));
 }

package/_src/FiberRef/api.ts

@@ -20,35 +20,35 @@ export function update_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?
 /**
  * @tsplus fluent fncts.io.FiberRef set
  */
-export function set_<A>(fiberRef: FiberRef<A>, a: A): UIO<void> {
+export function set_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<void> {
   return fiberRef.modify(() => [undefined, a]);
 }
 
 /**
  * @tsplus getter fncts.io.FiberRef get
  */
-export function get<A>(fiberRef: FiberRef<A>): UIO<A> {
+export function get<A>(fiberRef: FiberRef<A>, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((a) => [a, a]);
 }
 
 /**
  * @tsplus fluent fncts.io.FiberRef getAndSet
  */
-export function getAndSet_<A>(fiberRef: FiberRef<A>, a: A): UIO<A> {
+export function getAndSet_<A>(fiberRef: FiberRef<A>, a: A, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((v) => [v, a]);
 }
 
 /**
  * @tsplus fluent fncts.io.FiberRef getAndUpdate
  */
-export function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A): UIO<A> {
+export function getAndUpdate_<A>(fiberRef: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((a) => [a, f(a)]);
 }
 
 /**
  * @tsplus fluent fncts.io.FiberRef getAndUpdateJust
  */
-export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>): UIO<A> {
+export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A> {
   return fiberRef.modify((a) => [a, f(a).getOrElse(a)]);
 }
 
@@ -59,7 +59,7 @@ export function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) => Maybe<A
  *
  * @tsplus fluent fncts.io.FiberRef locally
  */
-export function locally_<A>(fiberRef: FiberRef<A>, value: A) {
+export function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => {
     return new FiberRefLocally(value, fiberRef, use);
   };
@@ -72,7 +72,7 @@ export function locally_<A>(fiberRef: FiberRef<A>, value: A) {
  *
  * @tsplus fluent fncts.io.FiberRef locallyWith
  */
-export function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A) {
+export function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> => self.getWith((a) => self.locally(f(a))(use));
 }
 

package/_src/FiberRef/constructors.ts

@@ -2,7 +2,8 @@ import { identity } from "@fncts/base/data/function";
 
 function makeWith<Value, Patch>(
   ref: Lazy<FiberRef.WithPatch<Value, Patch>>,
-): IO<Has<Scope>, never, FiberRef.WithPatch<Value, Patch>> {
+  __tsplusTrace?: string,
+): IO<Scope, never, FiberRef.WithPatch<Value, Patch>> {
   return IO.acquireRelease(
     IO.succeed(ref).tap((ref) => ref.update(identity)),
     (ref) => ref.remove,
@@ -16,6 +17,7 @@ export function make<A>(
   initial: A,
   fork: (a: A) => A = identity,
   join: (a: A, a1: A) => A = (_, a) => a,
-): IO<Has<Scope>, never, FiberRef<A>> {
+  __tsplusTrace?: string,
+): IO<Scope, never, FiberRef<A>> {
   return makeWith(FiberRef.unsafeMake(initial, fork, join));
 }

package/_src/FiberRef/unsafe.ts

@@ -1,7 +1,9 @@
 import type { LogSpan } from "../LogSpan.js";
+import type { Scheduler } from "@fncts/io/internal/Scheduler.js";
 
 import { identity } from "@fncts/base/data/function";
 import { Patch } from "@fncts/base/data/Patch";
+import { defaultScheduler } from "@fncts/io/internal/Scheduler";
 
 import { FiberRefInternal } from "./definition.js";
 
@@ -77,3 +79,8 @@ export const currentLogSpan = FiberRef.unsafeMake<List<LogSpan>>(Nil());
  * @tsplus static fncts.io.FiberRefOps currentLogAnnotations
  */
 export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.makeDefault());
+
+/**
+ * @tsplus static fncts.io.FiberRefOps currentScheduler
+ */
+export const currentScheduler = FiberRef.unsafeMake<Scheduler>(defaultScheduler);