@fncts/io 0.0.21 → 0.0.23

package/_src/Fiber/api/awaitAll.ts

@@ -4,5 +4,5 @@
  * @tsplus static fncts.io.FiberOps awaitAll
  */
 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;
+  return IO.foreachConcurrent(as, (f) => f.await.flatMap(IO.fromExitNow)).result;
 }

package/_src/Fiber/api/collectAll.ts

@@ -1,4 +1,5 @@
 import { SyntheticFiber } from "@fncts/io/Fiber/definition";
+
 /**
  * Collects all fibers into a single fiber producing an in-order list of the
  * results.
@@ -12,7 +13,7 @@ export function sequenceIterable<E, A>(
   return new SyntheticFiber(
     fibers.foldLeft(FiberId.none as FiberId, (b, a) => b.combine(a.id)),
     Fiber.awaitAll(fibers),
-    IO.foreachC(fibers, (fiber) => fiber.children).map((c) => c.flatten),
+    IO.foreachConcurrent(fibers, (fiber) => fiber.children).map((c) => c.flatten),
     IO.foreachDiscard(fibers, (f) => f.inheritRefs),
     IO.foreach(fibers, (f) => f.poll).map((exits) =>
       exits.foldRight(Just(Exit.succeed(Conc.empty()) as Exit<E, Conc<A>>), (a, b) =>
@@ -26,6 +27,6 @@ export function sequenceIterable<E, A>(
         ),
       ),
     ),
-    (fiberId) => IO.foreachDiscard(fibers, (fiber) => fiber.interruptAsFork(fiberId)),
+    (fiberId) => IO.foreach(fibers, (fiber) => fiber.interruptAsFork(fiberId)),
   );
 }

package/_src/Fiber/api/inheritRefs.ts

@@ -3,5 +3,5 @@
  */
 export function inheritRefs<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<void> {
   fiber.concrete();
-  return fiber.inheritRefs;
+  return fiber.inheritAll;
 }

package/_src/Fiber/api/interrupt.ts

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

package/_src/Fiber/api/interruptAs.ts

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

package/_src/Fiber/api/interruptFork.ts

@@ -6,5 +6,5 @@
  * @tsplus getter fncts.io.Fiber interruptFork
  */
 export function interruptFork<E, A>(fiber: Fiber<E, A>, __tsplusTrace?: string): UIO<void> {
-  return IO.descriptorWith(({ id }) => fiber.interruptAsFork(id));
+  return IO.fiberId.flatMap((id) => fiber.interruptAsFork(id));
 }

package/_src/Fiber/api/location.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus getter fncts.io.Fiber location
  */
-export function location<E, A>(self: Fiber<E, A>): TraceElement {
+export function location<E, A>(self: Fiber<E, A>): string | undefined {
   self.concrete();
-  return self._tag === "RuntimeFiber" ? self.location : TraceElement.NoLocation;
+  return self._tag === "RuntimeFiber" ? self.location : undefined;
 }

package/_src/Fiber/api/zipWith.ts

@@ -11,7 +11,7 @@ export function zipWith<A, E1, B, C>(that: Fiber<E1, B>, f: (a: A, b: B) => C, _
   return <E>(self: Fiber<E, A>): Fiber<E | E1, C> => {
     return new SyntheticFiber(
       self.id,
-      self.await.flatMap(IO.fromExitNow).zipWithC(that.await.flatMap(IO.fromExitNow), f).result,
+      self.await.flatMap(IO.fromExitNow).zipWithConcurrent(that.await.flatMap(IO.fromExitNow), f).result,
       self.children,
       that.inheritRefs > self.inheritRefs,
       self.poll.zipWith(that.poll, (ma, mb) =>

package/_src/Fiber/definition.ts

@@ -1,4 +1,12 @@
+import type { FiberId } from "@fncts/base/data/FiberId";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
+import type { UIO } from "@fncts/io/IO/definition";
+
+import { IterableWeakSet } from "@fncts/base/collection/weak/IterableWeakSet";
+
+export const FiberVariance = Symbol.for("fncts.io.Fiber.Variance");
+export type FiberVariance = typeof FiberVariance;
 
 export const FiberTypeId = Symbol.for("fncts.io.Fiber");
 export type FiberTypeId = typeof FiberTypeId;
@@ -7,10 +15,13 @@ export type FiberTypeId = typeof FiberTypeId;
  * @tsplus type fncts.io.Fiber
  */
 export interface Fiber<E, A> {
-  readonly _typeId: FiberTypeId;
-  readonly _E: () => E;
-  readonly _A: () => A;
+  readonly [FiberTypeId]: FiberTypeId;
+  readonly [FiberVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
 }
+
 /**
  * @tsplus type fncts.io.FiberOps
  */
@@ -25,24 +36,31 @@ export declare namespace Fiber {
 
 export interface FiberCommon<E, A> extends Fiber<E, A> {
   readonly id: FiberId;
+
   /**
    * Awaits the fiber, which suspends the awaiting fiber until the result of the
    * fiber has been determined.
    */
   readonly await: UIO<Exit<E, A>>;
+
   /**
    * Inherits values from all {@link FiberRef} instances into current fiber.
    * This will resume immediately.
    */
-  readonly inheritRefs: UIO<void>;
+  readonly inheritAll: UIO<void>;
+
   /**
-   * Interrupts the fiber as if interrupted from the specified fiber.
+   * 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.
    */
   readonly interruptAsFork: (fiberId: FiberId) => UIO<void>;
+
   /**
    * Tentatively observes the fiber, but returns immediately if it is not already done.
    */
   readonly poll: UIO<Maybe<Exit<E, A>>>;
+
   /**
    * Retrieves the immediate children of the fiber.
    */
@@ -51,28 +69,22 @@ export interface FiberCommon<E, A> extends Fiber<E, A> {
 
 export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
   readonly _tag: "RuntimeFiber";
+
   /**
    * The identity of the Fiber
    */
   readonly id: FiberId.Runtime;
+
   /**
    * The location the fiber was forked from
    */
-  readonly location: TraceElement;
-  /**
-   * Evaluates the specified effect on the fiber. If this is not possible,
-   * because the fiber has already ended life, then the specified alternate
-   * effect will be executed instead.
-   */
-  readonly evalOn: (effect: UIO<any>, orElse: UIO<any>) => UIO<void>;
-  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>;
+  readonly location?: string;
+
   /**
    * The status of the fiber.
    */
   readonly status: UIO<FiberStatus>;
+
   /**
    * The trace of the Fiber
    */
@@ -80,16 +92,21 @@ export interface RuntimeFiber<E, A> extends FiberCommon<E, A> {
 }
 
 export class SyntheticFiber<E, A> implements FiberCommon<E, A> {
-  readonly _tag                 = "SyntheticFiber";
-  readonly _typeId: FiberTypeId = FiberTypeId;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly _tag = "SyntheticFiber";
+
+  readonly [FiberTypeId]: FiberTypeId = FiberTypeId;
+  declare [FiberVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
+
   readonly await;
+
   constructor(
     readonly id: FiberId,
     wait: UIO<Exit<E, A>>,
     readonly children: UIO<Conc<Fiber.Runtime<any, any>>>,
-    readonly inheritRefs: UIO<void>,
+    readonly inheritAll: UIO<void>,
     readonly poll: UIO<Maybe<Exit<E, A>>>,
     readonly interruptAsFork: (fiberId: FiberId) => UIO<void>,
   ) {
@@ -108,5 +125,10 @@ export function concrete<E, A>(_fiber: Fiber<E, A>): asserts _fiber is ConcreteF
 }
 
 export function isFiber(u: unknown): u is Fiber<unknown, unknown> {
-  return hasTypeId(u, FiberTypeId);
+  return isObject(u) && FiberTypeId in u;
 }
+
+/**
+ * @tsplus static fncts.io.FiberOps _roots
+ */
+export const _roots: IterableWeakSet<FiberRuntime<any, any>> = new IterableWeakSet();

package/_src/Fiber.ts

@@ -1,22 +1,20 @@
 // codegen:start { preset: barrel, include: Fiber/*.ts }
 export * from "./Fiber/constructors.js";
 export * from "./Fiber/definition.js";
-export * from "./Fiber/FiberContext.js";
+export * from "./Fiber/FiberMessage.js";
+export * from "./Fiber/FiberRuntime.js";
 // codegen:end
 // codegen:start { preset: barrel, include: Fiber/api/*.ts }
 export * from "./Fiber/api/await.js";
 export * from "./Fiber/api/awaitAll.js";
 export * from "./Fiber/api/children.js";
 export * from "./Fiber/api/collectAll.js";
-export * from "./Fiber/api/evalOn.js";
-export * from "./Fiber/api/evalOnIO.js";
 export * from "./Fiber/api/fromIO.js";
 export * from "./Fiber/api/id.js";
 export * from "./Fiber/api/inheritRefs.js";
 export * from "./Fiber/api/interrupt.js";
 export * from "./Fiber/api/interruptAll.js";
 export * from "./Fiber/api/interruptAs.js";
-export * from "./Fiber/api/interruptAsFork.js";
 export * from "./Fiber/api/interruptFork.js";
 export * from "./Fiber/api/join.js";
 export * from "./Fiber/api/joinAll.js";

package/_src/FiberDescriptor.ts

@@ -1,5 +1,4 @@
 import type { FiberId } from "@fncts/base/data/FiberId";
-import type { FiberScope } from "@fncts/io/FiberScope";
 import type { FiberStatus } from "@fncts/io/FiberStatus";
 
 /**
@@ -9,11 +8,5 @@ import type { FiberStatus } from "@fncts/io/FiberStatus";
  * @tsplus companion fncts.io.FiberDescriptorOps
  */
 export class FiberDescriptor {
-  constructor(
-    readonly id: FiberId,
-    readonly status: FiberStatus,
-    readonly interruptors: ReadonlySet<FiberId>,
-    readonly interruptStatus: InterruptStatus,
-    readonly scope: FiberScope,
-  ) {}
+  constructor(readonly id: FiberId, readonly status: FiberStatus, readonly interruptors: HashSet<FiberId>) {}
 }

package/_src/FiberRef/api.ts

@@ -6,10 +6,10 @@ import { concrete } from "@fncts/io/FiberRef/definition";
 export function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string) {
   return (self: FiberRef<A>): UIO<B> => {
     concrete(self);
-    return IO.withFiberContext((fiber) =>
+    return IO.withFiberRuntime((fiber) =>
       IO(() => {
-        const [result, newValue] = f(fiber.unsafeGetRef(self));
-        fiber.unsafeSetRef(self, newValue);
+        const [result, newValue] = f(fiber.getFiberRef(self));
+        fiber.setFiberRef(self, newValue);
         return result;
       }),
     );
@@ -77,18 +77,11 @@ export function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: strin
  */
 export function locally<A>(fiberRef: FiberRef<A>, value: A, __tsplusTrace?: string) {
   return <R1, E1, B>(use: IO<R1, E1, B>): IO<R1, E1, B> =>
-    IO.withFiberContext((fiber) =>
-      IO.defer(() => {
-        const oldValue = fiber.unsafeGetRef(fiberRef);
-        fiber.unsafeSetRef(fiberRef, value);
-        fiber.unsafeAddFinalizer(
-          IO(() => {
-            fiber.unsafeSetRef(fiberRef, oldValue);
-          }),
-        );
-        return use;
-      }),
-    );
+    IO.withFiberRuntime((fiberState) => {
+      const oldValue = fiberState.getFiberRef(fiberRef);
+      fiberState.setFiberRef(fiberRef, value);
+      return use.ensuring(IO.succeed(fiberState.setFiberRef(fiberRef, oldValue)));
+    });
 }
 
 /**
@@ -107,7 +100,7 @@ export function locallyWith<A>(self: FiberRef<A>, f: (a: A) => A, __tsplusTrace?
  */
 export function getWith<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: string) {
   return (fiberRef: FiberRef<A>): IO<R, E, B> => {
-    return IO.withFiberContext((fiber) => f(fiber.unsafeGetRef(fiberRef)));
+    return fiberRef.get.flatMap(f);
   };
 }
 
@@ -115,7 +108,10 @@ export function getWith<A, R, E, B>(f: (a: A) => IO<R, E, B>, __tsplusTrace?: st
  * @tsplus getter fncts.io.FiberRef remove
  */
 export function remove<A>(self: FiberRef<A>, __tsplusTrace?: string): UIO<void> {
-  return IO.withFiberContext((fiber) => IO(fiber.unsafeDeleteRef(self)));
+  return IO.withFiberRuntime((fiberState) => {
+    fiberState.deleteFiberRef(self);
+    return IO.unit;
+  });
 }
 
 /**

package/_src/FiberRef/definition.ts

@@ -1,6 +1,9 @@
 import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
 
-export const FiberRefTypeId = Symbol.for("fncts.FiberRef");
+export const FiberRefVariance = Symbol.for("fncts.io.FiberRef.Variance");
+export type FiberRefVariance = typeof FiberRefVariance;
+
+export const FiberRefTypeId = Symbol.for("fncts.io.FiberRef");
 export type FiberRefTypeId = typeof FiberRefTypeId;
 
 /**
@@ -8,8 +11,10 @@ export type FiberRefTypeId = typeof FiberRefTypeId;
  * @tsplus companion fncts.io.FiberRefOps
  */
 export abstract class FiberRef<Value> {
-  readonly _typeId: FiberRefTypeId = FiberRefTypeId;
-  readonly _A!: () => Value;
+  readonly [FiberRefTypeId]: FiberRefTypeId = FiberRefTypeId;
+  declare [FiberRefVariance]: {
+    readonly _Value: (_: Value) => Value;
+  };
   readonly _Patch!: unknown;
 }
 
@@ -50,7 +55,7 @@ export class FiberRefInternal<Value, Patch> extends FiberRef<Value> implements H
 }
 
 export function isFiberRef(u: unknown): u is FiberRef<unknown> {
-  return hasTypeId(u, FiberRefTypeId);
+  return isObject(u) && FiberRefTypeId in u;
 }
 
 type Concrete<Value, Patch> = FiberRefInternal<Value, Patch>;

package/_src/FiberRef/unsafe.ts

@@ -64,6 +64,11 @@ export const forkScopeOverride = FiberRef.unsafeMake<Maybe<FiberScope>>(
   (parent, _) => parent,
 );
 
+/**
+ * @tsplus static fncts.io.FiberRefOps interruptedCause
+ */
+export const interruptedCause = FiberRef.unsafeMake(Cause.empty<never>(), identity, (parent, _) => parent);
+
 /**
  * @tsplus static fncts.io.FiberRefOps currentEnvironment
  */
@@ -87,7 +92,7 @@ export const currentLogSpan = FiberRef.unsafeMake<List<LogSpan>>(Nil());
 /**
  * @tsplus static fncts.io.FiberRefOps currentLogAnnotations
  */
-export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.makeDefault());
+export const currentLogAnnotations = FiberRef.unsafeMake<HashMap<string, string>>(HashMap.empty());
 
 /**
  * @tsplus static fncts.io.FiberRefOps currentScheduler

package/_src/FiberRefs/api.ts

@@ -1,17 +1,19 @@
+import { MaybeTag } from "@fncts/base/data/Maybe";
 import { FiberRefs } from "@fncts/io/FiberRefs/definition";
 
 /**
  * @tsplus getter fncts.io.FiberRefs fiberRefs
  */
 export function fiberRefs(self: FiberRefs): HashSet<FiberRef<unknown>> {
-  return self.fiberRefLocals.keySet;
+  return self.unFiberRefs.keySet;
 }
 
 /**
+ * @tsplus macro identity
  * @tsplus static fncts.io.FiberRefsOps __call
  */
 export function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>): FiberRefs {
-  return new FiberRefs(fiberRefLocals);
+  return FiberRefs.get(fiberRefLocals);
 }
 
 /**
@@ -19,7 +21,7 @@ export function make(fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [F
  */
 export function forkAs(childId: FiberId.Runtime) {
   return (self: FiberRefs): FiberRefs => {
-    const childFiberRefLocals = self.fiberRefLocals.mapWithIndex((fiberRef, stack) => {
+    const childFiberRefLocals = self.unFiberRefs.mapWithIndex((fiberRef, stack) => {
       const oldValue = stack.head[1];
       const newValue = fiberRef.patch(fiberRef.fork)(oldValue);
       if (oldValue === newValue) {
@@ -31,3 +33,54 @@ export function forkAs(childId: FiberId.Runtime) {
     return FiberRefs(childFiberRefLocals);
   };
 }
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs get
+ */
+export function get<A>(self: FiberRefs, fiberRef: FiberRef<A>): Maybe<A> {
+  return self.unFiberRefs.get(fiberRef).map((_) => _.head[1] as A);
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs getOrDefault
+ */
+export function getOrDefault<A>(self: FiberRefs, fiberRef: FiberRef<A>): A {
+  const v = self.unFiberRefs.get(fiberRef);
+  Maybe.concrete(v);
+  if (v._tag === MaybeTag.Just) {
+    return v.value.head[1] as A;
+  } else {
+    return fiberRef.initial;
+  }
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs updateAs
+ */
+export function updateAs<A>(self: FiberRefs, fiberId: FiberId.Runtime, fiberRef: FiberRef<A>, value: A): FiberRefs {
+  const oldStack = self.unFiberRefs.get(fiberRef).getOrElse(List.empty<readonly [FiberId.Runtime, unknown]>());
+  let newStack: Cons<readonly [FiberId.Runtime, unknown]>;
+  if (oldStack.isEmpty()) {
+    newStack = Cons([fiberId, value]);
+  } else if (oldStack.head[0] == fiberId) {
+    newStack = Cons([fiberId, value], oldStack.tail);
+  } else {
+    newStack = Cons([fiberId, value], oldStack);
+  }
+  return FiberRefs(self.unFiberRefs.set(fiberRef, newStack));
+}
+
+/**
+ * @tsplus fluent fncts.io.FiberRefs delete
+ */
+export function remove(self: FiberRefs, fiberRef: FiberRef<any>): FiberRefs {
+  return FiberRefs(self.unFiberRefs.remove(fiberRef));
+}
+
+/**
+ * @tsplus getter fncts.io.FiberRefs unFiberRefs
+ * @tsplus macro identity
+ */
+export function unFiberRefs(self: FiberRefs): HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>> {
+  return FiberRefs.reverseGet(self);
+}

package/_src/FiberRefs/definition.ts

@@ -1,11 +1,19 @@
-export const FiberRefsTypeId = Symbol.for("fncts.io.FiberRefs");
-export type FiberRefsTypeId = typeof FiberRefsTypeId;
+export interface FiberRefsN extends HKT {
+  readonly type: FiberRefs;
+}
 
 /**
  * @tsplus type fncts.io.FiberRefs
- * @tsplus companion fncts.io.FiberRefsOps
  */
-export class FiberRefs {
-  readonly _typeId: FiberRefsTypeId = FiberRefsTypeId;
-  constructor(readonly fiberRefLocals: HashMap<FiberRef<unknown>, Cons<readonly [FiberId.Runtime, unknown]>>) {}
-}
+export interface FiberRefs
+  extends Newtype<
+    { readonly FiberRefs: unique symbol },
+    HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>
+  > {}
+
+/**
+ * @tsplus type fncts.io.FiberRefsOps
+ */
+export interface FiberRefsOps extends NewtypeIso<FiberRefsN> {}
+
+export const FiberRefs: FiberRefsOps = Newtype();

package/_src/FiberRefs/join.ts

@@ -3,8 +3,8 @@
  */
 export function join(fiberId: FiberId.Runtime, that: FiberRefs) {
   return (self: FiberRefs): FiberRefs => {
-    const parentFiberRefs = self.fiberRefLocals;
-    const childFiberRefs  = that.fiberRefLocals;
+    const parentFiberRefs = FiberRefs.reverseGet(self);
+    const childFiberRefs  = FiberRefs.reverseGet(that);
     const fiberRefLocals  = childFiberRefs.foldLeftWithIndex(parentFiberRefs, (ref, parentFiberRefs, childStack) => {
       const childValue = childStack.head[1];
       if (childStack.head[0] == fiberId) {
@@ -37,13 +37,13 @@ export function join(fiberId: FiberId.Runtime, that: FiberRefs) {
         },
       );
     });
-    return FiberRefs(fiberRefLocals);
+    return FiberRefs.get(fiberRefLocals);
   };
 }
 
 function compareFiberId(left: FiberId.Runtime, right: FiberId.Runtime): number {
-  const compare = Number.Ord.compare(left.startTime, right.startTime);
-  return compare === 0 ? Number.Ord.compare(left.id, right.id) : compare;
+  const compare = Number.Ord.compare(right.startTime)(left.startTime);
+  return compare === 0 ? Number.Ord.compare(right.id)(left.id) : compare;
 }
 
 /**

package/_src/FiberScope/constructors.ts

@@ -1,4 +1,4 @@
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
 
 import { Global, Local } from "@fncts/io/FiberScope/definition";
 
@@ -14,6 +14,6 @@ export const global = new Global();
 /**
  * @tsplus static fncts.io.FiberScopeOps unsafeMake
  */
-export function unsafeMake(fiber: FiberContext<any, any>): FiberScope {
+export function unsafeMake(fiber: FiberRuntime<any, any>): FiberScope {
   return new Local(fiber.id, new WeakRef(fiber));
 }

package/_src/FiberScope/definition.ts

@@ -1,4 +1,7 @@
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
+
+import { FiberMessage } from "@fncts/io/Fiber";
 
 /**
  * A `Scope` represents the scope of a fiber lifetime. The scope of a fiber can
@@ -10,29 +13,38 @@ import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
  */
 export abstract class FiberScope {
   abstract fiberId: FiberId;
-  abstract unsafeAdd(child: FiberContext<unknown, unknown>): boolean;
+  abstract unsafeAdd(
+    currentFiber: FiberRuntime<any, any>,
+    runtimeFlags: RuntimeFlags,
+    child: FiberRuntime<any, any>,
+  ): void;
 }
 
 export class Global extends FiberScope {
   get fiberId(): FiberId {
     return FiberId.none;
   }
-  unsafeAdd(_child: FiberContext<any, any>): boolean {
-    return true;
+  unsafeAdd(_currentFiber: FiberRuntime<any, any>, runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void {
+    if (runtimeFlags.fiberRoots) {
+      Fiber._roots.add(child);
+    }
   }
 }
 
 export class Local extends FiberScope {
-  constructor(readonly fiberId: FiberId, private parentRef: WeakRef<FiberContext<unknown, unknown>>) {
+  constructor(readonly fiberId: FiberId, private parentRef: WeakRef<FiberRuntime<unknown, unknown>>) {
     super();
   }
-  unsafeAdd(child: FiberContext<unknown, unknown>): boolean {
+  unsafeAdd(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void {
     const parent = this.parentRef.deref();
     if (parent != null) {
-      parent.unsafeAddChild(child);
-      return true;
+      if (currentFiber === parent) {
+        parent.addChild(child);
+      } else {
+        parent.tell(FiberMessage.Stateful((parentFiber) => parentFiber.addChild(child)));
+      }
     } else {
-      return false;
+      child.tell(FiberMessage.InterruptSignal(Cause.interrupt(currentFiber.id)));
     }
   }
 }

package/_src/FiberStatus/constructors.ts

@@ -1,35 +1,23 @@
+import type { RuntimeFlags } from "../RuntimeFlags.js";
 import type { FiberStatus } from "./definition.js";
 
-import { Done, Finishing, Running, Suspended } from "./definition.js";
+import { Done, Running, Suspended } from "./definition.js";
 
 /**
  * @tsplus static fncts.FiberStatusOps done
  */
 export const done: FiberStatus = new Done();
 
-/**
- * @tsplus static fncts.FiberStatusOps finishing
- */
-export function finishing(interrupting: boolean): FiberStatus {
-  return new Finishing(interrupting);
-}
-
 /**
  * @tsplus static fncts.FiberStatusOps running
  */
-export function running(interrupting: boolean): FiberStatus {
-  return new Running(interrupting);
+export function running(runtimeFlags: RuntimeFlags, trace?: string): FiberStatus {
+  return new Running(runtimeFlags, trace);
 }
 
 /**
  * @tsplus static fncts.FiberStatusOps suspended
  */
-export function suspended(
-  interrupting: boolean,
-  interruptible: boolean,
-  epoch: number,
-  blockingOn: FiberId,
-  asyncTrace?: string,
-): FiberStatus {
-  return new Suspended(interrupting, interruptible, epoch, blockingOn, asyncTrace);
+export function suspended(runtimeFlags: RuntimeFlags, blockingOn: FiberId, trace?: string): FiberStatus {
+  return new Suspended(runtimeFlags, blockingOn, trace);
 }