@fncts/io 0.0.17 → 0.0.19

package/Cached/internal.d.ts

@@ -1,6 +1,6 @@
 import { FIO } from "@fncts/io/IO/definition";
 export declare const CachedTypeId: unique symbol;
-export declare type CachedTypeId = typeof CachedTypeId;
+export type CachedTypeId = typeof CachedTypeId;
 export declare abstract class CachedInternal<Error, Resource> {
     readonly _E: () => Error;
     readonly _A: () => Resource;

package/CancellerState.d.ts

@@ -18,7 +18,7 @@ export declare class Registered {
 /**
  * @tsplus type fncts.CancellerState
  */
-export declare type CancellerState = Empty | Pending | Registered;
+export type CancellerState = Empty | Pending | Registered;
 /**
  * @tsplus type fncts.CancellerStateOps
  */

package/Channel/ChildExecutorDecision/definition.d.ts

@@ -26,7 +26,7 @@ export declare const Yield: ChildExecutorDecision;
 /**
  * @tsplus type fncts.io.Channel.ChildExecutorDecision
  */
-export declare type ChildExecutorDecision = Continue | Close | Yield;
+export type ChildExecutorDecision = Continue | Close | Yield;
 /**
  * @tsplus type fncts.io.Channel.ChildExecutorDecisionOps
  */

package/Channel/UpstreamPullRequest/definition.d.ts

@@ -11,7 +11,7 @@ export declare class NoUpstream {
 /**
  * @tsplus type fncts.io.Channel.UpstreamPullRequest
  */
-export declare type UpstreamPullRequest<A> = Pulled<A> | NoUpstream;
+export type UpstreamPullRequest<A> = Pulled<A> | NoUpstream;
 /**
  * @tsplus type fncts.io.Channel.UpstreamPullRequestOps
  */

package/Channel/UpstreamPullStrategy/definition.d.ts

@@ -17,7 +17,7 @@ export interface PullAfterAllEnqueued<A> {
  * @tsplus location "@fncts/io/Channel/UpstreamPullStrategy/definition"
  */
 export declare function PullAfterAllEnqueued<A>(emitSeparator: Maybe<A>): UpstreamPullStrategy<A>;
-export declare type UpstreamPullStrategy<A> = PullAfterNext<A> | PullAfterAllEnqueued<A>;
+export type UpstreamPullStrategy<A> = PullAfterNext<A> | PullAfterAllEnqueued<A>;
 /**
  * @tsplus type fncts.io.Channel.UpstreamPullStrategyOps
  */

package/Channel/api/mergeAllWith.d.ts

@@ -3,7 +3,7 @@ import { IO } from "@fncts/io/IO/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Future } from "@fncts/io/Future";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
-export declare type MergeStrategy = "BackPressure" | "BufferSliding";
+export type MergeStrategy = "BackPressure" | "BufferSliding";
 /**
  * @tsplus fluent fncts.io.Channel mergeAllWith
  * @tsplus location "@fncts/io/Channel/api/mergeAllWith"

package/Channel/internal/ChannelExecutor.d.ts

@@ -8,7 +8,7 @@ import { ListBuffer } from "@fncts/base/collection/mutable/ListBuffer";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { ChannelState } from "@fncts/io/Channel/internal/ChannelState";
 import * as State from "@fncts/io/Channel/internal/ChannelState";
-export declare type ErasedExecutor<R> = ChannelExecutor<R, unknown, unknown, unknown, unknown, unknown, unknown>;
+export type ErasedExecutor<R> = ChannelExecutor<R, unknown, unknown, unknown, unknown, unknown, unknown>;
 export declare function readUpstream<R, E, A>(r: State.Read<R, E>, cont: () => IO<R, E, A>): IO<R, E, A>;
 export declare class ChannelExecutor<Env, InErr, InElem, InDone, OutErr, OutElem, OutDone> {
     private providedEnv;

package/Channel/internal/ChannelState.d.ts

@@ -8,7 +8,7 @@ export declare const enum ChannelStateTag {
     Read = "Read"
 }
 export declare const ChannelStateTypeId: unique symbol;
-export declare type ChannelStateTypeId = typeof ChannelStateTypeId;
+export type ChannelStateTypeId = typeof ChannelStateTypeId;
 export declare class Emit {
     readonly _tag = ChannelStateTag.Emit;
     readonly _R: (_: unknown) => void;
@@ -40,5 +40,5 @@ export declare class Read<R, E> {
     constructor(upstream: ErasedExecutor<R> | null, onEffect: (_: IO<R, never, void>) => IO<R, never, void>, onEmit: (_: any) => IO<R, never, void> | null, onDone: (exit: Exit<any, any>) => IO<R, never, void> | null);
     get effect(): IO<R, E, any>;
 }
-export declare type ChannelState<R, E> = Emit | Done | Effect<R, E> | Read<R, E>;
+export type ChannelState<R, E> = Emit | Done | Effect<R, E> | Read<R, E>;
 export declare function effectOrNullIgnored<R, E>(channelState: ChannelState<R, E> | null): IO<R, never, void> | null;

package/Channel/internal/MergeDecision.d.ts

@@ -5,7 +5,7 @@ export declare const enum MergeDecisionTag {
     Await = "Await"
 }
 export declare const MergeDecisionTypeId: unique symbol;
-export declare type MergeDecisionTypeId = typeof MergeDecisionTypeId;
+export type MergeDecisionTypeId = typeof MergeDecisionTypeId;
 /**
  * @tsplus type fncts.io.Channel.MergeDecision
  * @tsplus companion fncts.io.Channel.MergeDecisionOps

package/Channel/internal/MergeState.d.ts

@@ -26,7 +26,7 @@ export declare class RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> {
 /**
  * @tsplus type fncts.io.Channel.MergeState
  */
-export declare type MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> | LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> | RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>;
+export type MergeState<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> = BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> | LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> | RightDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2>;
 /**
  * @tsplus type fncts.io.Channel.MergeStateOps
  */

package/Channel/internal/SingleProducerAsyncInput.d.ts

@@ -34,7 +34,7 @@ export declare class StateEmit<Err, Elem, Done> {
     readonly _stateTag = StateTag.Emit;
     constructor(notifyConsumers: Queue<Future<Err, Either<Done, Elem>>>);
 }
-export declare type State<Err, Elem, Done> = StateEmpty | StateEmit<Err, Elem, Done> | StateError<Err> | StateDone<Done>;
+export type State<Err, Elem, Done> = StateEmpty | StateEmit<Err, Elem, Done> | StateError<Err> | StateDone<Done>;
 /**
  * An MVar-like abstraction for sending data to channels asynchronously. Designed
  * for one producer and multiple consumers.

package/Clock/definition.d.ts

@@ -11,6 +11,7 @@ export declare abstract class Clock {
 }
 /**
  * @tsplus static fncts.io.ClockOps Tag
+ * @tsplus implicit
  * @tsplus location "@fncts/io/Clock/definition"
  */
 export declare const ClockTag: import("@fncts/base/data/Tag").Tag<Clock>;

package/Fiber/FiberContext.d.ts

@@ -7,7 +7,6 @@ import { Maybe, Nothing, Just } from "@fncts/base/data/Maybe/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
-import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { RuntimeConfig, RuntimeConfigFlag } from "@fncts/io/RuntimeConfig";
 import { FiberRefs } from "@fncts/io/FiberRefs";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
@@ -16,10 +15,11 @@ import { Exit } from "@fncts/base/data/Exit/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { FiberScope } from "@fncts/io/FiberScope";
 import { Trace } from "@fncts/base/data/Trace/definition";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
-import { InterruptStatus } from "@fncts/io/InterruptStatus";
 import { isInterruptedException, IllegalStateError } from "@fncts/base/data/exceptions";
 import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
+import { InterruptStatus } from "@fncts/io/InterruptStatus";
 import { LogLevel } from "@fncts/io/LogLevel";
 import type { Instruction, Match } from "@fncts/io/IO/definition";
 import { TraceElement } from "@fncts/base/data/TraceElement";
@@ -28,9 +28,9 @@ import { Stack } from "@fncts/base/internal/Stack";
 import { FiberTypeId } from "@fncts/io/Fiber/definition";
 import { FiberState } from "@fncts/io/FiberState";
 import { FiberStatus } from "@fncts/io/FiberStatus";
-export declare type FiberRefLocals = AtomicReference<HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>>;
-declare type Erased = IO<any, any, any>;
-declare type ErasedCont = (a: any) => Erased;
+export type FiberRefLocals = HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>;
+type Erased = IO<any, any, any>;
+type ErasedCont = (a: any) => Erased;
 export declare class InterruptExit {
     readonly apply: ErasedCont;
     readonly trace?: string | undefined;
@@ -56,7 +56,7 @@ export declare class Finalizer {
     readonly _tag = "Finalizer";
     constructor(finalizer: IO<any, never, any>, apply: ErasedCont, trace?: string | undefined);
 }
-export declare type Frame = InterruptExit | Match<any, any, any, any, any, any, any, any, any> | HandlerFrame | TracedCont | Finalizer;
+export type Frame = InterruptExit | Match<any, any, any, any, any, any, any, any, any> | HandlerFrame | TracedCont | Finalizer;
 export declare const currentFiber: AtomicReference<FiberContext<any, any> | null>;
 export declare function unsafeCurrentFiber(): Maybe<FiberContext<any, any>>;
 /**
@@ -65,10 +65,10 @@ export declare function unsafeCurrentFiber(): Maybe<FiberContext<any, any>>;
  * @tsplus type fncts.io.Fiber
  */
 export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable, Equatable {
-    protected readonly fiberId: FiberId.Runtime;
-    private runtimeConfig;
-    private interruptStatus;
-    private fiberRefLocals;
+    readonly fiberId: FiberId.Runtime;
+    runtimeConfig: RuntimeConfig;
+    interruptStatus: Stack<boolean>;
+    fiberRefLocals: FiberRefLocals;
     private readonly _children;
     readonly _typeId: FiberTypeId;
     readonly _tag = "RuntimeFiber";
@@ -80,7 +80,6 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     private asyncEpoch;
     private stack;
     nextIO: Instruction | null;
-    private currentSupervisor;
     constructor(fiberId: FiberId.Runtime, runtimeConfig: RuntimeConfig, interruptStatus: Stack<boolean>, fiberRefLocals: FiberRefLocals, _children: Set<FiberContext<unknown, unknown>>);
     get poll(): import("@fncts/io/IO/definition").UIO<import("@fncts/base/data/Maybe").Maybe<import("@fncts/base/data/Exit").Exit<E, A>>>;
     get inheritRefs(): UIO<void>;
@@ -88,6 +87,7 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     awaitAsync(k: FiberState.Callback<E, A>): void;
     get children(): UIO<Conc<Fiber.Runtime<any, any>>>;
     evalOnIO<R1, E1, B, R2, E2, C>(effect: IO<R1, E1, B>, orElse: IO<R2, E2, C>, __tsplusTrace?: string): IO<R1 & R2, E1 | E2, B | C>;
+    get fiberRefs(): FiberRefs;
     get await(): UIO<Exit<E, A>>;
     run(): void;
     get scope(): FiberScope;
@@ -103,19 +103,19 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
      */
     runUntil(maxOpCount: number): void;
     unsafeRunLater(i0: Instruction): void;
-    private unsafeGetRef;
+    unsafeGetRef<A>(ref: FiberRef<A>): A;
     private unsafeGetRefs;
-    private unsafeSetRef;
-    private unsafeDeleteRef;
+    unsafeSetRef<A>(ref: FiberRef<A>, value: A): void;
+    unsafeDeleteRef<A>(ref: FiberRef<A>): void;
     unsafePoll(): import("@fncts/base/data/Maybe").Maybe<import("@fncts/base/data/Exit").Exit<E, A>>;
     private interruptExit;
-    private unsafeAddFinalizer;
-    private get unsafeIsInterruptible();
+    unsafeAddFinalizer(finalizer: IO<any, never, any>): void;
+    get unsafeIsInterruptible(): boolean;
     private get unsafeIsInterrupted();
     private get unsafeIsInterrupting();
     private get unsafeShouldInterrupt();
     private unsafeDisableInterruption;
-    private unsafeRestoreInterruptStatus;
+    unsafeRestoreInterruptStatus(): void;
     private unsafeAddSuppressedCause;
     /**
      * Unwinds the stack, looking for the first error handler, and exiting
@@ -126,7 +126,7 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     private unsafeNextEffect;
     private unsafeNotifyObservers;
     private unsafeRemoveObserver;
-    private unsafeInterruptAs;
+    interruptAsFork(fiberId: FiberId): UIO<void>;
     private unsafeTryDone;
     private unsafeSetAsyncCanceller;
     private unsafeReportUnhandled;
@@ -137,7 +137,7 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     private unsafeFork;
     unsafeOnDone(k: FiberState.Callback<never, Exit<E, A>>): void;
     private unsafeClearSuppressedCause;
-    private unsafeGetDescriptor;
+    unsafeGetDescriptor(): import("../FiberDescriptor").FiberDescriptor;
     private unsafeRace;
     private unsafeCompleteRace;
     private unsafeCaptureTrace;
@@ -146,5 +146,8 @@ export declare class FiberContext<E, A> implements Fiber.Runtime<E, A>, Hashable
     unsafeAddChild(child: FiberContext<unknown, unknown>): void;
     private unsafeLog;
     private unsafeLogWith;
+    private unsafeIsFatal;
+    private unsafeHandleFatalError;
+    get currentSupervisor(): Supervisor<any>;
 }
 export {};

package/Fiber/api/interruptAll.d.ts

@@ -6,7 +6,7 @@ import { UIO } from "@fncts/io/IO/definition";
  * @tsplus static fncts.io.FiberOps interruptAllAs
  * @tsplus location "@fncts/io/Fiber/api/interruptAll"
  */
-export declare function interruptAllAs_(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void>;
+export declare function interruptAllAs(fs: Iterable<Fiber<any, any>>, id: FiberId, __tsplusTrace?: string): UIO<void>;
 /**
  * Interrupts all fibers and awaits their interruption
  * @tsplus static fncts.io.FiberOps interruptAll

package/Fiber/api/interruptAsFork.d.ts

@@ -0,0 +1,8 @@
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus fluent fncts.io.Fiber interruptAsFork
+ * @tsplus location "@fncts/io/Fiber/api/interruptAsFork"
+ */
+export declare function interruptAsFork<E, A>(self: Fiber<E, A>, fiberId: FiberId): UIO<void>;

package/Fiber/definition.d.ts

@@ -7,7 +7,7 @@ import { TraceElement } from "@fncts/base/data/TraceElement/definition";
 import { Trace } from "@fncts/base/data/Trace/definition";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
 export declare const FiberTypeId: unique symbol;
-export declare type FiberTypeId = typeof FiberTypeId;
+export type FiberTypeId = typeof FiberTypeId;
 /**
  * @tsplus type fncts.io.Fiber
  */
@@ -39,11 +39,9 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
      */
     readonly inheritRefs: UIO<void>;
     /**
-     * Interrupts the fiber as if interrupted from the specified fiber. If the
-     * fiber has already exited, the returned effect will resume immediately.
-     * Otherwise, the effect will resume when the fiber exits.
+     * Interrupts the fiber as if interrupted from the specified fiber.
      */
-    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+    readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     /**
      * Tentatively observes the fiber, but returns immediately if it is not already done.
      */
@@ -84,15 +82,15 @@ export declare class SyntheticFiber<E, A> implements FiberCommon<E, A> {
     readonly children: UIO<Conc<Fiber.Runtime<any, any>>>;
     readonly inheritRefs: UIO<void>;
     readonly poll: UIO<Maybe<Exit<E, A>>>;
-    readonly interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>;
+    readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
     readonly _tag = "SyntheticFiber";
     readonly _typeId: FiberTypeId;
     readonly _E: () => E;
     readonly _A: () => A;
     readonly await: import("../IO").UIO<import("@fncts/base/data/Exit").Exit<E, A>>;
-    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritRefs: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAs: (fiberId: FiberId) => UIO<Exit<E, A>>);
+    constructor(id: FiberId, wait: UIO<Exit<E, A>>, children: UIO<Conc<Fiber.Runtime<any, any>>>, inheritRefs: UIO<void>, poll: UIO<Maybe<Exit<E, A>>>, interruptAsFork: (fiberId: FiberId) => UIO<void>);
 }
-export declare type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
+export type ConcreteFiber<E, A> = Fiber.Runtime<E, A> | Fiber.Synthetic<E, A>;
 /**
  * @tsplus fluent fncts.io.Fiber concrete
  * @tsplus macro remove

package/FiberRef/api.d.ts

@@ -43,7 +43,7 @@ export declare function getAndUpdateJust_<A>(fiberRef: FiberRef<A>, f: (a: A) =>
  * @tsplus fluent fncts.io.FiberRef locally
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string): <R1, E1, B>(use: import("@fncts/io/IO/definition").IO<R1, E1, B>) => import("@fncts/io/IO/definition").IO<R1, E1, B>;
+export declare function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
 /**
  * Returns an `IO` that runs with `f` applied to the current fiber.
  *
@@ -51,7 +51,7 @@ export declare function locally_<A>(fiberRef: FiberRef<A>, value: A, __tsplusTra
  * @tsplus fluent fncts.io.FiberRef locallyWith
  * @tsplus location "@fncts/io/FiberRef/api"
  */
-export declare function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): <R1, E1, B>(use: import("@fncts/io/IO/definition").IO<R1, E1, B>) => import("@fncts/io/IO/definition").IO<R1, E1, B>;
+export declare function locallyWith_<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?: string): <R1, E1, B>(use: import("../IO").IO<R1, E1, B>) => import("../IO").IO<R1, E1, B>;
 /**
  * @tsplus fluent fncts.io.FiberRef getWith
  * @tsplus location "@fncts/io/FiberRef/api"
@@ -87,3 +87,8 @@ export declare function patch<Value, Patch>(self: FiberRef.WithPatch<Value, Patc
  * @tsplus location "@fncts/io/FiberRef/api"
  */
 export declare function fork<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>): Patch;
+/**
+ * @tsplus fluent fncts.io.FiberRef join
+ * @tsplus location "@fncts/io/FiberRef/api"
+ */
+export declare function join<Value, Patch>(self: FiberRef.WithPatch<Value, Patch>, oldValue: Value, newValue: Value): Value;

package/FiberRef/definition.d.ts

@@ -1,7 +1,7 @@
 import { Hashable } from "@fncts/base/typeclass/Hashable";
 import { Equatable } from "@fncts/base/typeclass/Equatable";
 export declare const FiberRefTypeId: unique symbol;
-export declare type FiberRefTypeId = typeof FiberRefTypeId;
+export type FiberRefTypeId = typeof FiberRefTypeId;
 /**
  * @tsplus type fncts.io.FiberRef
  * @tsplus companion fncts.io.FiberRefOps
@@ -25,14 +25,15 @@ export declare class FiberRefInternal<Value, Patch> extends FiberRef<Value> impl
     readonly _combine: (first: Patch, second: Patch) => Patch;
     readonly _patch: (patch: Patch) => (oldValue: Value) => Value;
     readonly _fork: Patch;
+    readonly _join: (oldValue: Value, newValue: Value) => Value;
     readonly _Patch: Patch;
     private readonly id;
-    constructor(_initial: Value, _diff: (oldValue: Value, newValue: Value) => Patch, _combine: (first: Patch, second: Patch) => Patch, _patch: (patch: Patch) => (oldValue: Value) => Value, _fork: Patch);
+    constructor(_initial: Value, _diff: (oldValue: Value, newValue: Value) => Patch, _combine: (first: Patch, second: Patch) => Patch, _patch: (patch: Patch) => (oldValue: Value) => Value, _fork: Patch, _join: (oldValue: Value, newValue: Value) => Value);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
 export declare function isFiberRef(u: unknown): u is FiberRef<unknown>;
-declare type Concrete<Value, Patch> = FiberRefInternal<Value, Patch>;
+type Concrete<Value, Patch> = FiberRefInternal<Value, Patch>;
 /**
  * @tsplus macro remove
  */

package/FiberRef/unsafe.d.ts

@@ -5,14 +5,16 @@ import { FiberScope } from "@fncts/io/FiberScope";
 import { LogLevel } from "@fncts/io/LogLevel";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
 import type { LogSpan } from "../LogSpan.js";
 import type { Scheduler } from "@fncts/io/internal/Scheduler.js";
 import { Patch } from "@fncts/base/data/Patch";
+import { IsFatal } from "../internal/IsFatal.js";
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMakePatch
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
-export declare function unsafeMakePatch<Value, Patch>(initial: Value, diff: (oldValue: Value, newValue: Value) => Patch, combine: (first: Patch, second: Patch) => Patch, patch: (patch: Patch) => (oldValue: Value) => Value, fork: Patch): FiberRef.WithPatch<Value, Patch>;
+export declare function unsafeMakePatch<Value, Patch>(initial: Value, diff: (oldValue: Value, newValue: Value) => Patch, combine: (first: Patch, second: Patch) => Patch, patch: (patch: Patch) => (oldValue: Value) => Value, fork: Patch, join?: (oldValue: Value, newValue: Value) => Value): FiberRef.WithPatch<Value, Patch>;
 /**
  * @tsplus static fncts.io.FiberRefOps unsafeMakeEnvironment
  * @tsplus location "@fncts/io/FiberRef/unsafe"
@@ -58,3 +60,18 @@ export declare const currentLogAnnotations: import("./definition.js").FiberRef.W
  * @tsplus location "@fncts/io/FiberRef/unsafe"
  */
 export declare const currentScheduler: import("./definition.js").FiberRef.WithPatch<Scheduler, (_: Scheduler) => Scheduler>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentSupervisor
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const currentSupervisor: import("./definition.js").FiberRef.WithPatch<import("../Supervisor.js").Supervisor<any>, (_: import("../Supervisor.js").Supervisor<any>) => import("../Supervisor.js").Supervisor<any>>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentIsFatal
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const currentIsFatal: import("./definition.js").FiberRef.WithPatch<IsFatal, (_: IsFatal) => IsFatal>;
+/**
+ * @tsplus static fncts.io.FiberRefOps currentReportFatal
+ * @tsplus location "@fncts/io/FiberRef/unsafe"
+ */
+export declare const currentReportFatal: import("./definition.js").FiberRef.WithPatch<(t: unknown) => never, (_: (t: unknown) => never) => (t: unknown) => never>;

package/FiberRefs/api.d.ts

@@ -14,3 +14,8 @@ export declare function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>>;
  * @tsplus location "@fncts/io/FiberRefs/api"
  */
 export declare function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs;
+/**
+ * @tsplus fluent fncts.io.FiberRefs forkAs
+ * @tsplus location "@fncts/io/FiberRefs/api"
+ */
+export declare function forkAs(self: FiberRefs, childId: FiberId.Runtime): FiberRefs;

package/FiberRefs/definition.d.ts

@@ -3,7 +3,7 @@ import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Cons } from "@fncts/base/collection/immutable/List/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 export declare const FiberRefsTypeId: unique symbol;
-export declare type FiberRefsTypeId = typeof FiberRefsTypeId;
+export type FiberRefsTypeId = typeof FiberRefsTypeId;
 /**
  * @tsplus type fncts.io.FiberRefs
  * @tsplus companion fncts.io.FiberRefsOps

package/FiberState/definition.d.ts

@@ -7,7 +7,7 @@ import { FiberStatus } from "../FiberStatus.js";
 /**
  * @tsplus type fncts.FiberState
  */
-export declare type FiberState<E, A> = Executing<E, A> | Done<E, A>;
+export type FiberState<E, A> = Executing<E, A> | Done<E, A>;
 /**
  * @tsplus type fncts.FiberStateOps
  */
@@ -17,7 +17,7 @@ export declare const FiberState: FiberStateOps;
 export declare namespace FiberState {
     type Callback<E, A> = (exit: Exit<E, A>) => void;
 }
-export declare type Callback<E, A> = (exit: Exit<E, A>) => void;
+export type Callback<E, A> = (exit: Exit<E, A>) => void;
 export declare class Executing<E, A> {
     status: FiberStatus;
     observers: Set<Callback<never, Exit<E, A>>>;

package/FiberStatus/definition.d.ts

@@ -50,7 +50,7 @@ export declare class Suspended {
 /**
  * @tsplus type fncts.FiberStatus
  */
-export declare type FiberStatus = Done | Finishing | Running | Suspended;
+export type FiberStatus = Done | Finishing | Running | Suspended;
 /**
  * @tsplus type fncts.FiberStatusOps
  */

package/Future/definition.d.ts

@@ -24,4 +24,4 @@ export declare class Done<E, A> {
     readonly _tag = FutureStateTag.Done;
     constructor(value: FIO<E, A>);
 }
-export declare type State<E, A> = Done<E, A> | Pending<E, A>;
+export type State<E, A> = Done<E, A> | Pending<E, A>;

package/Hub/definition.d.ts

@@ -2,7 +2,7 @@ import { PQueue } from "@fncts/io/Queue/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 export declare const HubTypeId: unique symbol;
-export declare type HubTypeId = typeof HubTypeId;
+export type HubTypeId = typeof HubTypeId;
 /**
  * A `Hub<RA, RB, EA, EB, A, B>` is an asynchronous message hub. Publishers
  * can publish messages of type `A` to the hub and subscribers can subscribe to

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

@@ -1,10 +1,11 @@
 import { UIO, URIO } from "@fncts/io/IO/definition";
+import { FiberRef } from "@fncts/io/FiberRef/definition";
 import { Just } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Fiber } from "@fncts/io/Fiber/definition";
 import { FiberScope } from "../../FiberScope.js";
-import { GetForkScope, IO } from "../definition.js";
+import { IO } from "../definition.js";
 /**
  * @tsplus getter fncts.io.IO daemonChildren
  * @tsplus location "@fncts/io/IO/api/core-scope"
@@ -21,7 +22,7 @@ export declare const forkScope: UIO<FiberScope>;
  * @tsplus static fncts.io.IOOps forkScopeWith
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
-export declare function forkScopeWith<R, E, A>(f: (_: FiberScope) => IO<R, E, A>, __tsplusTrace?: string): GetForkScope<R, E, A>;
+export declare function forkScopeWith<R, E, A>(f: (_: FiberScope) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 export declare class ForkScopeRestore {
     private scope;
     constructor(scope: FiberScope);
@@ -42,7 +43,7 @@ export declare function forkScopeMask_<R, E, A>(newScope: FiberScope, f: (restor
  * @tsplus location "@fncts/io/IO/api/core-scope"
  */
 export declare function raceWith_<R, E, A, R1, E1, A1, R2, E2, A2, R3, E3, A3>(left: IO<R, E, A>, right: Lazy<IO<R1, E1, A1>>, leftWins: (exit: Exit<E, A>, fiber: Fiber<E1, A1>) => IO<R2, E2, A2>, rightWins: (exit: Exit<E1, A1>, fiber: Fiber<E, A>) => IO<R3, E3, A3>, __tsplusTrace?: string): IO<R | R1 | R2 | R3, E2 | E3, A2 | A3>;
-export declare type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
+export type Grafter = <R, E, A>(effect: IO<R, E, A>) => IO<R, E, A>;
 /**
  * Transplants specified effects so that when those effects fork other
  * effects, the forked effects will be governed by the scope of the

package/IO/api/interrupt.d.ts

@@ -104,6 +104,6 @@ export declare function disconnect<R, E, A>(self: IO<R, E, A>, __tsplusTrace?: s
 export declare class InterruptStatusRestore {
     readonly flag: InterruptStatus;
     constructor(flag: InterruptStatus);
-    restore: <R, E, A>(io: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R, E, A>;
-    force: <R, E, A>(io: import("../definition.js").IO<R, E, A>) => import("../definition.js").IO<R, E, A>;
+    restore: <R, E, A>(io: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;
+    force: <R, E, A>(io: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;
 }

package/IO/api/supervised.d.ts

@@ -0,0 +1,10 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Supervisor } from "@fncts/io/Supervisor/definition";
+/**
+ *
+ * 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
+ * @tsplus location "@fncts/io/IO/api/supervised"
+ */
+export declare function supervised_<R, E, A>(fa: IO<R, E, A>, supervisor: Supervisor<any>, __tsplusTrace?: string): IO<R, E, A>;

package/IO/api.d.ts

@@ -16,8 +16,8 @@ import { Exit } from "@fncts/base/data/Exit/definition";
 import { Trace } from "@fncts/base/data/Trace/definition";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { FiberRefs } from "@fncts/io/FiberRefs";
+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";
@@ -271,7 +271,7 @@ export declare function deferTryCatchWith<R, E, A, E1>(io: (runtimeConfig: Runti
  * @tsplus static fncts.io.IOOps descriptor
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare const descriptor: IO<never, never, import("../FiberDescriptor").FiberDescriptor>;
+export declare const descriptor: IO<never, never, import("../FiberDescriptor.js").FiberDescriptor>;
 /**
  * Constructs an IO based on information about the current fiber, such as
  * its identity.
@@ -972,14 +972,6 @@ export declare function succeedNow<A>(value: A, __tsplusTrace?: string): IO<neve
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function succeed<A>(effect: Lazy<A>, __tsplusTrace?: string): UIO<A>;
-/**
- *
- * 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
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function supervised_<R, E, A>(fa: IO<R, E, A>, supervisor: Supervisor<any>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus fluent fncts.io.IO summarized
  * @tsplus location "@fncts/io/IO/api"
@@ -1080,6 +1072,11 @@ export declare function unsandbox<R, E, A>(ma: IO<R, Cause<E>, A>, __tsplusTrace
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function updateFiberRefs(f: (fiberId: FiberId.Runtime, fiberRefs: FiberRefs) => FiberRefs, __tsplusTrace?: string): UIO<void>;
+/**
+ * @tsplus static fncts.io.IOOps withFiberContext
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function withFiberContext<R, E, A>(onState: (fiber: FiberContext<E, A>, status: FiberStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus fluent fncts.io.IO __call
  * @tsplus location "@fncts/io/IO/api"