@fncts/io 0.0.21 → 0.0.22

package/IO/api/fork.d.ts

@@ -0,0 +1,36 @@
+import { IO, URIO } from "@fncts/io/IO/definition";
+import { FiberScope } from "@fncts/io/FiberScope";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
+import { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+/**
+ * Returns an IO that forks this IO into its own separate fiber,
+ * returning the fiber immediately, without waiting for it to begin executing
+ * the IO.
+ *
+ * You can use the `fork` method whenever you want to execute an IO in a
+ * new fiber, concurrently and without "blocking" the fiber executing other
+ * IOs. Using fibers can be tricky, so instead of using this method
+ * directly, consider other higher-level methods, such as `raceWith`,
+ * `zipPar`, and so forth.
+ *
+ * The fiber returned by this method has methods interrupt the fiber and to
+ * wait for it to finish executing the IO. See `Fiber` for more
+ * information.
+ *
+ * Whenever you use this method to launch a new fiber, the new fiber is
+ * attached to the parent fiber's scope. This means when the parent fiber
+ * terminates, the child fiber will be terminated as well, ensuring that no
+ * fibers leak. This behavior is called "None supervision", and if this
+ * behavior is not desired, you may use the `forkDaemon` or `forkIn`
+ * methods.
+ * @tsplus getter fncts.io.IO fork
+ * @tsplus location "@fncts/io/IO/api/fork"
+ */
+export declare function fork<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberRuntime<E, A>>;
+/**
+ * @tsplus pipeable fncts.io.IO forkWithScopeOverride
+ * @tsplus location "@fncts/io/IO/api/fork"
+ */
+export declare function forkWithScopeOverride(scopeOverride: FiberScope | null, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").URIO<R, FiberRuntime<E, A>>;
+export declare function unsafeFork<R, E, A, E1, B>(effect: IO<R, E, A>, parentFiber: FiberRuntime<E1, B>, parentRuntimeFlags: RuntimeFlags, overrideScope: FiberScope | null, trace?: string): FiberRuntime<E, A>;
+export declare function unsafeMakeChildFiber<R, E, A, E1, B>(effect: IO<R, E, A>, parentFiber: FiberRuntime<E1, B>, parentRuntimeFlags: RuntimeFlags, overrideScope: FiberScope | null, trace?: string): FiberRuntime<E, A>;

package/IO/api/interrupt.d.ts

@@ -1,8 +1,8 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { FIO, IO } from "@fncts/io/IO/definition";
-import { InterruptStatus } from "@fncts/io/InterruptStatus";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { InterruptStatus } from "@fncts/io/InterruptStatus";
 /**
  * Returns an effect that is interrupted as if by the specified fiber.
  * @tsplus static fncts.io.IOOps interruptAs
@@ -16,15 +16,6 @@ export declare function interruptAs(fiberId: FiberId, __tsplusTrace?: string): F
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
 export declare const interrupt: IO<never, never, never>;
-/**
- * Switches the interrupt status for this effect. If `true` is used, then the
- * effect becomes interruptible (the default), while if `false` is used, then
- * the effect becomes uninterruptible. These changes are compositional, so
- * they only affect regions of the effect.
- * @tsplus pipeable fncts.io.IO setInterruptStatus
- * @tsplus location "@fncts/io/IO/api/interrupt"
- */
-export declare function setInterruptStatus(flag: InterruptStatus, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R, E, A>;
 /**
  * Returns a new effect that performs the same operations as this effect, but
  * interruptibly, even if composed inside of an uninterruptible region.
@@ -59,7 +50,12 @@ export declare function uninterruptible<R, E, A>(self: IO<R, E, A>, __tsplusTrac
  * @tsplus static fncts.io.IOOps uninterruptibleMask
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+export declare function uninterruptibleMask<R, E, A>(f: (restore: InterruptStatusRestore) => IO<R, E, A>): IO<R, E, A>;
+/**
+ * @tsplus pipeable fncts.io.IO ensuring
+ * @tsplus location "@fncts/io/IO/api/interrupt"
+ */
+export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R1 | R, E, A>;
 /**
  * Makes the effect interruptible, but passes it a restore function that can
  * be used to restore the inherited interruptibility from whatever region the
@@ -71,17 +67,17 @@ export declare function interruptibleMask<R, E, A>(k: (restore: InterruptStatusR
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted.
- * @tsplus pipeable fncts.io.IO onInterrupt
+ * @tsplus fluent fncts.io.IO onInterrupt
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterrupt_<R1>(cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(ma: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E, A>;
+export declare function onInterrupt_<R, E, A, R1>(ma: IO<R, E, A>, cleanup: (interruptors: HashSet<FiberId>) => IO<R1, never, any>, __tsplusTrace?: string): IO<R | R1, E, A>;
 /**
  * Calls the specified function, and runs the effect it returns, if this
  * effect is interrupted (allows for expanding error).
- * @tsplus pipeable fncts.io.IO onInterruptExtended
+ * @tsplus fluent fncts.io.IO onInterruptExtended
  * @tsplus location "@fncts/io/IO/api/interrupt"
  */
-export declare function onInterruptExtended_<R2, E2>(cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R2 | R, E2 | E, A>;
+export declare function onInterruptExtended_<R, E, A, R2, E2>(self: IO<R, E, A>, cleanup: Lazy<IO<R2, E2, any>>, __tsplusTrace?: string): IO<R | R2, E | E2, A>;
 /**
  * Returns an IO whose interruption will be disconnected from the
  * fiber's own interruption, being performed in the background without
@@ -104,6 +100,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").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>;
+    restore: <R, E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R, E, A>;
+    force: <R, E, A>(io: import("@fncts/io/IO/definition").IO<R, E, A>) => import("@fncts/io/IO/definition").IO<R, E, A>;
 }

package/IO/api/race.d.ts

@@ -10,4 +10,4 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus pipeable fncts.io.IO race
  * @tsplus location "@fncts/io/IO/api/race"
  */
-export declare function race<R1, E1, A1>(that: IO<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(io: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, A1 | A>;
+export declare function race<R1, E1, A1>(that: IO<R1, E1, A1>): <R, E, A>(io: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, A1 | A>;

package/IO/api/supervised.d.ts

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

package/IO/api/zipConcurrent.d.ts

@@ -0,0 +1,13 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+/**
+ * @tsplus pipeable fncts.io.IO zipConcurrent
+ * @tsplus location "@fncts/io/IO/api/zipConcurrent"
+ */
+export declare function zipConcurrent<R1, E1, B>(that: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, readonly [A, B]>;
+/**
+ * @tsplus pipeable fncts.io.IO zipWithConcurrent
+ * @tsplus location "@fncts/io/IO/api/zipConcurrent"
+ */
+export declare function zipWithConcurrent<A, R1, E1, B, C>(that: IO<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(self: import("../definition").IO<R, E, A>) => import("../definition").IO<R1 | R, E1 | E, C>;

package/IO/api.d.ts

@@ -1,12 +1,10 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { InterruptStatus } from "@fncts/io/InterruptStatus";
 import { URIO, FIO, UIO } from "@fncts/io/IO/definition";
-import { RuntimeConfig } from "@fncts/io/RuntimeConfig";
-import { FiberDescriptor } from "@fncts/io/FiberDescriptor";
+import { Either } from "@fncts/base/data/Either/definition";
 import { Conc, ConcBuilder } from "@fncts/base/collection/immutable/Conc";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
@@ -17,11 +15,11 @@ 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 { FiberRefs } from "@fncts/io/FiberRefs";
-import type { FiberStatus } from "../FiberStatus.js";
+import type { Running } from "../FiberStatus.js";
 import type * as P from "@fncts/base/typeclass";
 import type { _E, _R } from "@fncts/base/types";
-import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
-import type { Canceler } from "@fncts/io/IO/definition";
+import type { FiberRuntime } from "@fncts/io/Fiber/FiberRuntime";
+import type { RuntimeFlags } from "@fncts/io/RuntimeFlags";
 import { pipe } from "@fncts/base/data/function";
 import { IO } from "@fncts/io/IO/definition";
 /**
@@ -30,34 +28,6 @@ import { IO } from "@fncts/io/IO/definition";
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function async<R, E, A>(register: (resolve: (_: IO<R, E, A>) => void) => void, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Imports an asynchronous effect into a pure `IO`, possibly returning the value synchronously.
- *
- * If the register function returns a value synchronously, then the callback
- * function must not be called. Otherwise the callback function must be called at most once.
- * @tsplus static fncts.io.IOOps asyncMaybe
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function asyncMaybe<R, E, A>(register: (resolve: (_: IO<R, E, A>) => void) => Maybe<IO<R, E, A>>, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Imports an asynchronous side-effect into an IO. The side-effect
- * has the option of returning the value synchronously, which is useful in
- * cases where it cannot be determined if the effect is synchronous or
- * asynchronous until the side-effect is actually executed. The effect also
- * has the option of returning a canceler, which will be used by the runtime
- * to cancel the asynchronous effect if the fiber executing the effect is
- * interrupted.
- *
- * If the register function returns a value synchronously, then the callback
- * function must not be called. Otherwise the callback function must be called
- * at most once.
- *
- * The list of fibers, that may complete the async callback, is used to
- * provide better diagnostics.
- * @tsplus static fncts.io.IOOps asyncInterrupt
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function asyncInterrupt<R, E, A>(register: (cb: (resolve: IO<R, E, A>) => void) => Either<Canceler<R>, IO<R, E, A>>, blockingOn?: FiberId, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Attempts to convert defects into a failure, throwing away all information
  * about the cause of the failure.
@@ -66,18 +36,18 @@ export declare function asyncInterrupt<R, E, A>(register: (cb: (resolve: IO<R, E
  */
 export declare function absorbWith<R, E, A>(f: (e: E) => unknown, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R, unknown, A>;
 /**
- * @tsplus pipeable fncts.io.IO apFirst
+ * @tsplus pipeable fncts.io.IO zipLeft
  * @tsplus pipeable-operator fncts.io.IO <
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function apFirst<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
+export declare function zipLeft<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, A>;
 /**
  * Combine two effectful actions, keeping only the result of the second
- * @tsplus pipeable fncts.io.IO apSecond
+ * @tsplus pipeable fncts.io.IO zipRight
  * @tsplus pipeable-operator fncts.io.IO >
  * @tsplus location "@fncts/io/IO/api"
  */
-export declare function apSecond<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, B>;
+export declare function zipRight<R1, E1, B>(fb: IO<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E1 | E, B>;
 /**
  * @tsplus pipeable fncts.io.IO as
  * @tsplus location "@fncts/io/IO/api"
@@ -180,6 +150,13 @@ export declare function cause<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string):
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function causeAsError(__tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R, import("@fncts/base/data/Cause.js").Cause<E>, A>;
+/**
+ * Checks the interrupt status, and produces the IO returned by the
+ * specified callback.
+ * @tsplus static fncts.io.IOOps checkInterruptible
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function checkInterruptible<R, E, A>(f: (i: InterruptStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns an IO that models the execution of this effect, followed by
  * the passing of its value to the specified continuation function `f`,
@@ -193,13 +170,6 @@ export declare function flatMap<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tspl
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function flatMapError<R1, E, E1>(f: (e: E) => IO<R1, never, E1>, __tsplusTrace?: string): <R, A>(ma: IO<R, E, A>) => IO<R1 | R, E1, A>;
-/**
- * Checks the interrupt status, and produces the IO returned by the
- * specified callback.
- * @tsplus static fncts.io.IOOps checkInterruptible
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function checkInterruptible<R, E, A>(f: (i: InterruptStatus) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * @tsplus pipeable fncts.io.IO collect
  * @tsplus location "@fncts/io/IO/api"
@@ -224,15 +194,6 @@ export declare function condIO<R, R1, E, A>(b: boolean, onTrue: URIO<R, A>, onFa
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function defer<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
-/**
- * Returns a lazily constructed effect, whose construction may itself require
- * effects. The effect must not throw any exceptions. When no environment is required (i.e., when R == unknown)
- * it is conceptually equivalent to `flatten(effectTotal(io))`. If you wonder if the effect throws exceptions,
- * do not use this method, use `IO.deferTryCatchWith`.
- * @tsplus static fncts.io.IOOps deferWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function deferWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects.
  * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(try(io))`.
@@ -240,13 +201,6 @@ export declare function deferWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function deferTry<R, E, A>(io: () => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
-/**
- * Returns a lazily constructed effect, whose construction may itself require effects.
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
- * @tsplus static IOOps deferTryWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function deferTryWith<R, E, A>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, __tsplusTrace?: string): IO<R, unknown, A>;
 /**
  * Returns a lazily constructed effect, whose construction may itself require effects,
  * translating any thrown exceptions into typed failed effects and mapping the error.
@@ -256,38 +210,12 @@ export declare function deferTryWith<R, E, A>(io: (runtimeConfig: RuntimeConfig,
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function deferTryCatch<R, E, A, E1>(io: () => IO<R, E, A>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
-/**
- * Returns a lazily constructed effect, whose construction may itself require effects,
- * translating any thrown exceptions into typed failed effects and mapping the error.
- *
- * When no environment is required (i.e., when R == unknown) it is conceptually equivalent to `flatten(effect(io))`.
- * @tsplus static IOOps deferTryCatchWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function deferTryCatchWith<R, E, A, E1>(io: (runtimeConfig: RuntimeConfig, id: FiberId) => IO<R, E, A>, onThrow: (error: unknown) => E1, __tsplusTrace?: string): IO<R, E | E1, A>;
-/**
- * @tsplus static fncts.io.IOOps descriptor
- * @tsplus location "@fncts/io/IO/api"
- */
-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.
- * @tsplus static fncts.io.IOOps descriptorWith
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function descriptorWith<R, E, A>(f: (d: FiberDescriptor) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
 /**
  * Folds an `IO` that may fail with `E` or succeed with `A` into one that never fails but succeeds with `Either<E, A>`
  * @tsplus getter fncts.io.IO either
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function either<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, Either<E, A>>;
-/**
- * @tsplus pipeable fncts.io.IO ensuring
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: IO<R, E, A>) => IO<R1 | R, E, A>;
 /**
  * @tsplus pipeable fncts.io.IO errorAsCause
  * @tsplus location "@fncts/io/IO/api"
@@ -313,6 +241,11 @@ export declare function fail<E>(e: Lazy<E>, __tsplusTrace?: string): FIO<E, neve
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function failNow<E>(e: E, __tsplusTrace?: string): FIO<E, never>;
+/**
+ * @tsplus static fncts.io.IOOps refailCause
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function refailCause<E>(cause: Cause<E>, __tsplusTrace?: string): FIO<E, never>;
 /**
  * Creates a `IO` that has failed with the specified `Cause`
  * @tsplus static fncts.io.IOOps failCauseNow
@@ -444,31 +377,6 @@ export declare function foreachDiscard<A, R, E, B>(as: Iterable<A>, f: (a: A) =>
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function forever<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, never>;
-/**
- * Returns an IO that forks this IO into its own separate fiber,
- * returning the fiber immediately, without waiting for it to begin executing
- * the IO.
- *
- * You can use the `fork` method whenever you want to execute an IO in a
- * new fiber, concurrently and without "blocking" the fiber executing other
- * IOs. Using fibers can be tricky, so instead of using this method
- * directly, consider other higher-level methods, such as `raceWith`,
- * `zipC`, and so forth.
- *
- * The fiber returned by this method has methods interrupt the fiber and to
- * wait for it to finish executing the IO. See `Fiber` for more
- * information.
- *
- * Whenever you use this method to launch a new fiber, the new fiber is
- * attached to the parent fiber's scope. This means when the parent fiber
- * terminates, the child fiber will be terminated as well, ensuring that no
- * fibers leak. This behavior is called "None supervision", and if this
- * behavior is not desired, you may use the `forkDaemon` or `forkIn`
- * methods.
- * @tsplus getter fncts.io.IO fork
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function fork<R, E, A>(ma: IO<R, E, A>, __tsplusTrace?: string): URIO<R, FiberContext<E, A>>;
 /**
  * Lifts an `Either` into an `IO`
  * @tsplus static fncts.io.IOOps fromEither
@@ -746,13 +654,6 @@ export declare function merge<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string):
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function mergeAll<R, E, A, B>(fas: Iterable<IO<R, E, A>>, b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): IO<R, E, B>;
-/**
- * Returns a `IO` that will never produce anything. The moral equivalent of
- * `while(true) {}`, only without the wasted CPU cycles.
- * @tsplus static fncts.io.IOOps never
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare const never: UIO<never>;
 /**
  * Converts an option on errors into an option on values.
  * @tsplus getter fncts.io.IO optional
@@ -927,12 +828,6 @@ export declare function retryWhile<E>(f: (e: E) => boolean, __tsplusTrace?: stri
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function retryWhileIO<E, R1, E1>(f: (e: E) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, A>(fa: IO<R, E, A>) => IO<R1 | R, E | E1, A>;
-/**
- * Retrieves the runtimeConfig that this effect is running on.
- * @tsplus static fncts.io.IOOps runtimeConfig
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare const runtimeConfig: UIO<RuntimeConfig>;
 /**
  * Exposes the full cause of failure of this effect.
  * @tsplus getter fncts.io.IO sandbox
@@ -944,12 +839,6 @@ export declare function sandbox<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function sandboxWith<R, E, A, E1>(f: (_: IO<R, Cause<E>, A>) => IO<R, Cause<E1>, A>, __tsplusTrace?: string): (ma: IO<R, E, A>) => IO<R, E1, A>;
-/**
- * Sets the runtime configuration to the specified value.
- * @tsplus static fncts.io.IOOps setRuntimeConfig
- * @tsplus location "@fncts/io/IO/api"
- */
-export declare function setRuntimeConfig(runtimeConfig: Lazy<RuntimeConfig>, __tsplusTrace?: string): UIO<void>;
 /**
  * @tsplus static fncts.io.IOOps sequenceIterable
  * @tsplus location "@fncts/io/IO/api"
@@ -1075,11 +964,6 @@ 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"
@@ -1096,6 +980,21 @@ export declare function when(b: Lazy<boolean>, __tsplusTrace?: string): <R, E, A
  * @tsplus location "@fncts/io/IO/api"
  */
 export declare function whenIO<R1, E1>(mb: IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E, A>(ma: IO<R, E, A>) => IO<R1 | R, E1 | E, void>;
+/**
+ * @tsplus static fncts.io.IOOps withFiberRuntime
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function withFiberRuntime<R, E, A>(onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+/**
+ * @tsplus static fncts.io.IOOps updateRuntimeFlags
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function updateRuntimeFlags(patch: RuntimeFlags.Patch, __tsplusTrace?: string): IO<never, never, void>;
+/**
+ * @tsplus static fncts.io.IOOps stackTrace
+ * @tsplus location "@fncts/io/IO/api"
+ */
+export declare function stackTrace(__tsplusTrace?: string): UIO<Trace>;
 /**
  * Returns an effect that yields to the runtime system, starting on a fresh
  * stack. Manual use of this method can improve fairness, at the cost of