@fncts/io 0.0.39 → 0.0.40

package/_src/Channel/UpstreamPullStrategy.ts

@@ -1,3 +1,4 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./UpstreamPullStrategy/*.ts }
 export * from "./UpstreamPullStrategy/definition.js";
 // codegen:end

package/_src/Channel/internal/ChannelExecutor.ts

@@ -169,7 +169,10 @@ class DrainChildExecutors<R> {
 
 class Emit<R> {
   readonly _tag = SubexecutorStackTag.Emit;
-  constructor(readonly value: unknown, readonly next: Subexecutor<R> | null) {}
+  constructor(
+    readonly value: unknown,
+    readonly next: Subexecutor<R> | null,
+  ) {}
   close(ex: Exit<unknown, unknown>): URIO<R, unknown> | null {
     return this.next !== null ? this.next.close(ex) : null;
   }

package/_src/Channel/internal/MergeState.ts

@@ -6,7 +6,10 @@ export const enum MergeStateTag {
 
 export class BothRunning<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> {
   readonly _tag = MergeStateTag.BothRunning;
-  constructor(readonly left: Fiber<Err, Either<Done, Elem>>, readonly right: Fiber<Err1, Either<Done1, Elem>>) {}
+  constructor(
+    readonly left: Fiber<Err, Either<Done, Elem>>,
+    readonly right: Fiber<Err1, Either<Done1, Elem>>,
+  ) {}
 }
 
 export class LeftDone<Env, Err, Err1, Err2, Elem, Done, Done1, Done2> {

package/_src/Channel.ts

@@ -1,5 +1,6 @@
-// codegen:start { preset: barrel, include: ./Channel/*.ts, exclude: ./Channel/*(ChildExecutorDecision|UpstreamPullRequest|UpstreamPullStrategy).ts }
-export * from "./Channel/api.js";
-export * from "./Channel/core-api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Channel/*.ts, exclude: Channel/*(ChildExecutorDecision|UpstreamPullRequest|UpstreamPullStrategy).ts }
 export * from "./Channel/definition.js";
+export * from "./Channel/core-api.js";
+export * from "./Channel/api.js";
 // codegen:end

package/_src/Clock.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Clock/*.ts }
-export * from "./Clock/api.js";
-export * from "./Clock/definition.js";
 export * from "./Clock/live.js";
+export * from "./Clock/definition.js";
+export * from "./Clock/api.js";
 // codegen:end

package/_src/Console.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Console/*.ts }
-export * from "./Console/api.js";
-export * from "./Console/definition.js";
 export * from "./Console/live.js";
+export * from "./Console/definition.js";
+export * from "./Console/api.js";
 // codegen:end

package/_src/CountdownLatch.ts

@@ -7,7 +7,10 @@ export type CountdownLatchTypeId = typeof CountdownLatchTypeId;
  */
 export class CountdownLatch {
   readonly [CountdownLatchTypeId]: CountdownLatchTypeId = CountdownLatchTypeId;
-  constructor(private _count: Ref<number>, private _waiters: Future<never, void>) {}
+  constructor(
+    private _count: Ref<number>,
+    private _waiters: Future<never, void>,
+  ) {}
 
   readonly await: UIO<void> = this._waiters.await;
 

package/_src/Fiber/FiberRuntime.ts

@@ -20,7 +20,10 @@ import { FiberMessage, FiberMessageTag } from "./FiberMessage.js";
 
 export class RevertFlags {
   readonly _tag = IOTag.RevertFlags;
-  constructor(readonly patch: RuntimeFlags.Patch, readonly trace?: string) {}
+  constructor(
+    readonly patch: RuntimeFlags.Patch,
+    readonly trace?: string,
+  ) {}
 }
 
 export class UpdateTrace {
@@ -41,7 +44,11 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
   };
   readonly _tag = "RuntimeFiber";
 
-  constructor(readonly fiberId: FiberId.Runtime, fiberRefs0: FiberRefs, readonly runtimeFlags0: RuntimeFlags) {
+  constructor(
+    readonly fiberId: FiberId.Runtime,
+    fiberRefs0: FiberRefs,
+    readonly runtimeFlags0: RuntimeFlags,
+  ) {
     this._fiberRefs    = fiberRefs0;
     this._runtimeFlags = runtimeFlags0;
   }
@@ -521,6 +528,9 @@ export class FiberRuntime<E, A> implements Fiber.Runtime<E, A> {
             cur = IO.concrete(IO.succeedNow(cur.value));
             break;
           }
+          case "Tag": {
+            cur = IO.concrete(IO.service(cur));
+          }
         }
       } catch (e) {
         if (isIOError(e)) {

package/_src/Fiber.ts

@@ -1,26 +1,28 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Fiber/*.ts }
-export * from "./Fiber/constructors.js";
 export * from "./Fiber/definition.js";
-export * from "./Fiber/FiberMessage.js";
+export * from "./Fiber/constructors.js";
 export * from "./Fiber/FiberRuntime.js";
+export * from "./Fiber/FiberMessage.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // 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/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/interruptFork.js";
-export * from "./Fiber/api/join.js";
-export * from "./Fiber/api/joinAll.js";
-export * from "./Fiber/api/location.js";
-export * from "./Fiber/api/mapFiber.js";
-export * from "./Fiber/api/mapIO.js";
-export * from "./Fiber/api/poll.js";
 export * from "./Fiber/api/zipWith.js";
+export * from "./Fiber/api/poll.js";
+export * from "./Fiber/api/mapIO.js";
+export * from "./Fiber/api/mapFiber.js";
+export * from "./Fiber/api/location.js";
+export * from "./Fiber/api/joinAll.js";
+export * from "./Fiber/api/join.js";
+export * from "./Fiber/api/interruptFork.js";
+export * from "./Fiber/api/interruptAs.js";
+export * from "./Fiber/api/interruptAll.js";
+export * from "./Fiber/api/interrupt.js";
+export * from "./Fiber/api/inheritRefs.js";
+export * from "./Fiber/api/id.js";
+export * from "./Fiber/api/fromIO.js";
+export * from "./Fiber/api/collectAll.js";
+export * from "./Fiber/api/children.js";
+export * from "./Fiber/api/awaitAll.js";
+export * from "./Fiber/api/await.js";
 // codegen:end

package/_src/FiberDescriptor.ts

@@ -8,5 +8,9 @@ import type { FiberStatus } from "@fncts/io/FiberStatus";
  * @tsplus companion fncts.io.FiberDescriptorOps
  */
 export class FiberDescriptor {
-  constructor(readonly id: FiberId, readonly status: FiberStatus, readonly interruptors: HashSet<FiberId>) {}
+  constructor(
+    readonly id: FiberId,
+    readonly status: FiberStatus,
+    readonly interruptors: HashSet<FiberId>,
+  ) {}
 }

package/_src/FiberRef.ts

@@ -1,11 +1,13 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: FiberRef/*.ts }
-export * from "./FiberRef/api.js";
-export * from "./FiberRef/constructors.js";
-export * from "./FiberRef/definition.js";
-export * from "./FiberRef/operations.js";
 export * from "./FiberRef/unsafe.js";
+export * from "./FiberRef/operations.js";
+export * from "./FiberRef/definition.js";
+export * from "./FiberRef/constructors.js";
+export * from "./FiberRef/api.js";
 // codegen:end
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./FiberRef/api/*.ts }
-export * from "./FiberRef/api/locallyScoped.js";
 export * from "./FiberRef/api/locallyScopedWith.js";
+export * from "./FiberRef/api/locallyScoped.js";
 // codegen:end

package/_src/FiberRefs/Patch.ts

@@ -0,0 +1,145 @@
+export const enum FiberRefsPatchTag {
+  Empty,
+  Add,
+  Remove,
+  Update,
+  AndThen,
+}
+
+export const FiberRefsPatchTypeId = Symbol.for("fncts.io.FiberRefs.Patch");
+export type FiberRefsPatchTypeId = typeof FiberRefsPatchTypeId;
+
+/**
+ * @tsplus type fncts.io.FiberRefs.Patch
+ * @tsplus companion fncts.io.FiberRefs.PatchOps
+ */
+export abstract class FiberRefsPatch {
+  readonly [FiberRefsPatchTypeId]: FiberRefsPatchTypeId = FiberRefsPatchTypeId;
+}
+
+export class Empty extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Empty;
+}
+
+export class Add<Value> extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Add;
+
+  constructor(
+    readonly fiberRef: FiberRef<Value>,
+    readonly value: Value,
+  ) {
+    super();
+  }
+}
+
+export class AndThen extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.AndThen;
+
+  constructor(
+    readonly first: FiberRefsPatch,
+    readonly second: FiberRefsPatch,
+  ) {
+    super();
+  }
+}
+
+export class Remove<Value> extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Remove;
+
+  constructor(readonly fiberRef: FiberRef<Value>) {
+    super();
+  }
+}
+
+export class Update<Value, Patch> extends FiberRefsPatch {
+  readonly _tag = FiberRefsPatchTag.Update;
+
+  constructor(
+    readonly fiberRef: FiberRef.WithPatch<Value, Patch>,
+    readonly patch: Patch,
+  ) {
+    super();
+  }
+}
+
+export const empty: FiberRefsPatch = new Empty();
+
+/**
+ * @tsplus pipeable fncts.io.FiberRefs.Patch combine
+ */
+export function combine(second: FiberRefsPatch) {
+  return (first: FiberRefsPatch): FiberRefsPatch => {
+    return new AndThen(first, second);
+  };
+}
+
+/**
+ * @tsplus static fncts.io.FiberRefs.PatchOps diff
+ */
+export function diff(oldValue: FiberRefs, newValue: FiberRefs): FiberRefsPatch {
+  const [removed, patch] = newValue.unFiberRefs.foldLeftWithIndex(
+    [oldValue, empty] as const,
+    (fiberRef, [fiberRefs, patch], values) => {
+      const newValue = values.head[1];
+      return fiberRefs.get(fiberRef).match(
+        () => [fiberRefs.delete(fiberRef), patch.combine(new Add(fiberRef, newValue))],
+        (oldValue) => {
+          if (oldValue === newValue) {
+            return [fiberRefs.delete(fiberRef), patch];
+          } else {
+            return [fiberRefs.delete(fiberRef), patch.combine(new Update(fiberRef, fiberRef.diff(oldValue, newValue)))];
+          }
+        },
+      );
+    },
+  );
+
+  return removed.unFiberRefs.foldLeftWithIndex(patch, (fiberRef, patch) => patch.combine(new Remove(fiberRef)));
+}
+
+/**
+ * @tsplus pipeable fncts.io.FiberRefs.Patch __call
+ */
+export function apply(fiberId: FiberId.Runtime, fiberRefs: FiberRefs) {
+  return (self: FiberRefsPatch): FiberRefs => {
+    return applyLoop(fiberId, fiberRefs, Cons(self));
+  };
+}
+
+/**
+ * @tsplus tailRec
+ */
+function applyLoop(fiberId: FiberId.Runtime, fiberRefs: FiberRefs, patches: List<FiberRefsPatch>): FiberRefs {
+  if (patches.isEmpty()) {
+    return fiberRefs;
+  }
+  const patch = patches.head;
+  const rest  = patches.tail;
+  concrete(patch);
+  switch (patch._tag) {
+    case FiberRefsPatchTag.Add:
+      return applyLoop(fiberId, fiberRefs.updateAs(fiberId, patch.fiberRef, patch.value), rest);
+    case FiberRefsPatchTag.AndThen:
+      return applyLoop(fiberId, fiberRefs, Cons(patch.first, Cons(patch.second, rest)));
+    case FiberRefsPatchTag.Empty:
+      return applyLoop(fiberId, fiberRefs, rest);
+    case FiberRefsPatchTag.Remove:
+      return applyLoop(fiberId, fiberRefs.delete(patch.fiberRef), rest);
+    case FiberRefsPatchTag.Update:
+      return applyLoop(
+        fiberId,
+        fiberRefs.updateAs(
+          fiberId,
+          patch.fiberRef,
+          patch.fiberRef.patch(patch.patch)(fiberRefs.getOrDefault(patch.fiberRef)),
+        ),
+        rest,
+      );
+  }
+}
+
+type Concrete = Empty | Add<any> | Remove<any> | Update<any, any> | AndThen;
+
+function concrete(patch: FiberRefsPatch): asserts patch is Concrete {
+  //
+}

package/_src/FiberRefs.ts

@@ -1,4 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./FiberRefs/*.ts }
-export * from "./FiberRefs/api.js";
 export * from "./FiberRefs/definition.js";
+export * from "./FiberRefs/api.js";
+export * from "./FiberRefs/Patch.js";
 // codegen:end

package/_src/FiberScope/definition.ts

@@ -32,7 +32,10 @@ export class Global extends FiberScope {
 }
 
 export class Local extends FiberScope {
-  constructor(readonly fiberId: FiberId, private parentRef: WeakRef<FiberRuntime<unknown, unknown>>) {
+  constructor(
+    readonly fiberId: FiberId,
+    private parentRef: WeakRef<FiberRuntime<unknown, unknown>>,
+  ) {
     super();
   }
   unsafeAdd(currentFiber: FiberRuntime<any, any>, _runtimeFlags: RuntimeFlags, child: FiberRuntime<any, any>): void {

package/_src/FiberScope.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: FiberScope/*.ts }
-export * from "./FiberScope/constructors.js";
 export * from "./FiberScope/definition.js";
+export * from "./FiberScope/constructors.js";
 // codegen:end

package/_src/FiberStatus/definition.ts

@@ -20,7 +20,10 @@ export class Done {
  */
 export class Running {
   readonly _tag = FiberStatusTag.Running;
-  constructor(readonly runtimeFlags: RuntimeFlags, readonly trace?: string) {}
+  constructor(
+    readonly runtimeFlags: RuntimeFlags,
+    readonly trace?: string,
+  ) {}
   readonly isFinished = false;
 }
 
@@ -29,7 +32,11 @@ export class Running {
  */
 export class Suspended {
   readonly _tag = FiberStatusTag.Suspended;
-  constructor(readonly runtimeFlags: RuntimeFlags, readonly blockingOn: FiberId, readonly trace?: string) {}
+  constructor(
+    readonly runtimeFlags: RuntimeFlags,
+    readonly blockingOn: FiberId,
+    readonly trace?: string,
+  ) {}
   readonly isFinished = false;
 }
 

package/_src/FiberStatus.ts

@@ -1,4 +1,5 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: FiberStatus/*.ts }
-export * from "./FiberStatus/constructors.js";
 export * from "./FiberStatus/definition.js";
+export * from "./FiberStatus/constructors.js";
 // codegen:end

package/_src/Future/definition.ts

@@ -14,7 +14,10 @@ export class Future<in out E, in out A> {
     readonly _A: (_: A) => A;
     readonly _E: (_: E) => E;
   };
-  constructor(public state: State<E, A>, readonly blockingOn: FiberId) {}
+  constructor(
+    public state: State<E, A>,
+    readonly blockingOn: FiberId,
+  ) {}
 }
 
 export declare namespace Future {

package/_src/Future.ts

@@ -1,5 +1,6 @@
+/* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: Future/*.ts }
-export * from "./Future/api.js";
-export * from "./Future/constructors.js";
 export * from "./Future/definition.js";
+export * from "./Future/constructors.js";
+export * from "./Future/api.js";
 // codegen:end

package/_src/Hub/api.ts

@@ -108,7 +108,10 @@ export function dimapIO<A, B, RC, EC, C, RD, ED, D>(
 }
 
 class FilterInputIO<RA, RA1, RB, EA, EA1, EB, A, B> extends PHubInternal<RA | RA1, RB, EA | EA1, EB, A, B> {
-  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: A) => IO<RA1, EA1, boolean>) {
+  constructor(
+    readonly source: PHubInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (a: A) => IO<RA1, EA1, boolean>,
+  ) {
     super();
   }
   awaitShutdown = this.source.awaitShutdown;
@@ -147,7 +150,10 @@ export function filterInput<A>(f: (a: A) => boolean, __tsplusTrace?: string) {
 }
 
 class FilterOutputIO<RA, RB, RB1, EA, EB, EB1, A, B> extends PHubInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
-  constructor(readonly source: PHubInternal<RA, RB, EA, EB, A, B>, readonly f: (a: B) => IO<RB1, EB1, boolean>) {
+  constructor(
+    readonly source: PHubInternal<RA, RB, EA, EB, A, B>,
+    readonly f: (a: B) => IO<RB1, EB1, boolean>,
+  ) {
     super();
   }
   awaitShutdown = this.source.awaitShutdown;

package/_src/Hub.ts

@@ -1,4 +1,5 @@
-// codegen:start { preset: barrel, include: ./Hub/*.ts, exclude: ./Hub/*internal.ts }
-export * from "./Hub/api.js";
+/* eslint-disable simple-import-sort/exports */
+// codegen:start { preset: barrel, include: ./Hub/*.ts, exclude: Hub/*internal.ts }
 export * from "./Hub/definition.js";
+export * from "./Hub/api.js";
 // codegen:end

package/_src/IO/api/concurrentFinalizers.ts

@@ -1,11 +1,78 @@
+/**
+ * @tsplus getter fncts.io.IO sequentialFinalizers
+ */
+export function sequentialFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => IO.defer(io),
+      (scope) => {
+        if (scope.executionStrategy._tag === "Sequential") {
+          return IO.defer(io);
+        } else {
+          return scope.forkWith(ExecutionStrategy.sequential).flatMap((scope) => scope.extend(io));
+        }
+      },
+    ),
+  );
+}
+
 /**
  * @tsplus getter fncts.io.IO concurrentFinalizers
  */
-export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, A> {
-  return Do((Δ) => {
-    const outerScope = Δ(IO.scope);
-    const innerScope = Δ(Scope.concurrent);
-    Δ(outerScope.addFinalizerExit(Finalizer.get((exit) => innerScope.close(exit))));
-    return Δ(innerScope.extend(io));
-  });
+export function concurrentFinalizers<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => IO.defer(io),
+      (scope) => {
+        if (scope.executionStrategy._tag === "Concurrent") {
+          return IO.defer(io);
+        } else {
+          return scope.forkWith(ExecutionStrategy.concurrent).flatMap((scope) => scope.extend(io));
+        }
+      },
+    ),
+  );
+}
+
+/**
+ * @tsplus static fncts.io.IOOps concurrentFinalizersMask
+ */
+export function concurrentFinalizersMask<R, E, A>(
+  f: (restore: <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>) => IO<R, E, A>,
+  __tsplusTrace?: string,
+): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => f(Function.identity),
+      (scope) =>
+        scope.executionStrategy.match(
+          () => f(sequentialFinalizersRestorer).concurrentFinalizers,
+          () => f(concurrentFinalizersRestorer).concurrentFinalizers,
+          (n) => f((io) => concurrentBoundedFinalizersRestorer(io, n)).concurrentFinalizers,
+        ),
+    ),
+  );
+}
+
+function sequentialFinalizersRestorer<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+  return io.sequentialFinalizers;
+}
+
+function concurrentFinalizersRestorer<R, E, A>(io: IO<R, E, A>): IO<R, E, A> {
+  return io.concurrentFinalizers;
+}
+
+function concurrentBoundedFinalizersRestorer<R, E, A>(io: IO<R, E, A>, n: number): IO<R, E, A> {
+  return IO.environmentWithIO((environment) =>
+    environment.getMaybe(Scope.Tag).match(
+      () => io,
+      (scope) => {
+        if (scope.executionStrategy._tag === "ConcurrentBounded") {
+          return io;
+        } else {
+          return scope.forkWith(ExecutionStrategy.concurrentBounded(n)).flatMap((scope) => scope.extend(io));
+        }
+      },
+    ),
+  );
 }

package/_src/IO/api/foreachConcurrent.ts

@@ -66,20 +66,22 @@ function foreachConcurrentUnboundedDiscard<R, E, A>(
       const future = Future.unsafeMake<void, void>(FiberId.none);
       const ref    = new AtomicNumber(0);
       return IO.transplant((graft) =>
-        IO.foreach(
-          as,
-          (a) =>
-            graft(
-              restore(IO.defer(f(a))).matchCauseIO(
-                (cause) => future.fail(undefined).zipRight(IO.failCauseNow(cause)),
-                () => {
-                  if (ref.incrementAndGet() === size) {
-                    future.unsafeDone(IO.unit);
-                  }
-                  return IO.unit;
-                },
-              ),
-            ).forkDaemon,
+        IO.concurrentFinalizersMask((restoreFinalizers) =>
+          IO.foreach(
+            as,
+            (a) =>
+              graft(
+                restore(restoreFinalizers(IO.defer(f(a)))).matchCauseIO(
+                  (cause) => future.fail(undefined).zipRight(IO.failCauseNow(cause)),
+                  () => {
+                    if (ref.incrementAndGet() === size) {
+                      future.unsafeDone(IO.unit);
+                    }
+                    return IO.unit;
+                  },
+                ),
+              ).forkDaemon,
+          ),
         ),
       ).flatMap((fibers) =>
         restore(future.await).matchCauseIO(

package/_src/IO/api/interrupt.ts

@@ -1,4 +1,4 @@
-import { IOPrimitive,IOTag } from "@fncts/io/IO/definition";
+import { IOPrimitive, IOTag } from "@fncts/io/IO/definition";
 import { RuntimeFlag } from "@fncts/io/RuntimeFlag";
 import { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 

package/_src/IO/api/patchFiberRefs.ts

@@ -0,0 +1,8 @@
+import type { FiberRefsPatch } from "@fncts/io/FiberRefs";
+
+/**
+ * @tsplus static fncts.io.IOOps patchFiberRefs
+ */
+export function patchFiberRefs(patch: FiberRefsPatch): UIO<void> {
+  return IO.updateFiberRefs((fiberId, fiberRefs) => patch(fiberId, fiberRefs));
+}

package/_src/IO/api/provideSomeRuntime.ts

@@ -0,0 +1,22 @@
+import type { Runtime } from "@fncts/io/IO";
+
+import { FiberRefsPatch } from "@fncts/io/FiberRefs";
+import { defaultRuntime } from "@fncts/io/IO";
+
+/**
+ * @tsplus pipeable fncts.io.IO provideSomeRuntime
+ */
+export function provideSomeRuntime<R>(runtime: Runtime<R>) {
+  return <R1, E, A>(self: IO<R1, E, A>): IO<Exclude<R1, R>, E, A> => {
+    const patchFlags        = defaultRuntime.runtimeFlags.diff(runtime.runtimeFlags);
+    const inversePatchFlags = runtime.runtimeFlags.diff(defaultRuntime.runtimeFlags);
+    const patchRefs         = FiberRefsPatch.diff(defaultRuntime.fiberRefs, runtime.fiberRefs);
+    const inversePatchRefs  = FiberRefsPatch.diff(runtime.fiberRefs, defaultRuntime.fiberRefs);
+
+    return IO.bracket(
+      IO.updateRuntimeFlags(patchFlags) > IO.patchFiberRefs(patchRefs),
+      () => self.provideSomeEnvironment(runtime.environment),
+      () => IO.updateRuntimeFlags(inversePatchFlags) > IO.patchFiberRefs(inversePatchRefs),
+    );
+  };
+}

package/_src/IO/api.ts

@@ -2007,7 +2007,10 @@ export class GenIO<R, E, A> {
   readonly _E!: () => E;
   readonly _A!: () => A;
 
-  constructor(readonly effect: IO<R, E, A>, readonly _trace?: string) {}
+  constructor(
+    readonly effect: IO<R, E, A>,
+    readonly _trace?: string,
+  ) {}
 
   *[Symbol.iterator](): Generator<GenIO<R, E, A>, A, any> {
     return yield this;

package/_src/IO/definition.ts

@@ -50,6 +50,10 @@ declare module "@fncts/base/data/Exit/definition" {
   interface Failure<E> extends IO<never, E, never> {}
 }
 
+declare module "@fncts/base/data/Tag/definition" {
+  interface Tag<T, Identifier = T> extends IO<never, never, T> {}
+}
+
 /**
  * @tsplus type fncts.io.IOAspects
  */
@@ -259,7 +263,8 @@ export type Primitive =
   | Nothing
   | Just<any>
   | Failure<any>
-  | Success<any>;
+  | Success<any>
+  | Tag<any>;
 
 /**
  * @tsplus static fncts.io.IOOps concrete