@fncts/io 0.0.21 → 0.0.23

package/Ref/definition.d.ts

@@ -1,76 +1,111 @@
-import { UIO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 import type { Atomic as Atomic_ } from "./Atomic.js";
-import type { Synchronized as Synchronized_ } from "./Synchronized.js";
+import type * as Synchro from "./Synchronized/definition.js";
+export declare const RefVariance: unique symbol;
+export type RefVariance = typeof RefVariance;
 export declare const RefTypeId: unique symbol;
 export type RefTypeId = typeof RefTypeId;
+/**
+ * @tsplus type fncts.io.Ref
+ */
+export interface PRef<RA, RB, EA, EB, A, B> {
+    readonly [RefTypeId]: RefTypeId;
+    readonly [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+}
+export type Ref<A> = PRef<never, never, never, never, A, A>;
+export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
+export declare namespace PRef {
+    type Synchronized<RA, RB, EA, EB, A, B> = Synchro.PSynchronized<RA, RB, EA, EB, A, B>;
+}
+export declare namespace ERef {
+    type Synchronized<E, A> = Synchro.PSynchronized<never, never, E, E, A, A>;
+}
 export declare namespace Ref {
     type Atomic<A> = Atomic_<A>;
-    type Synchronized<A> = Synchronized_<A>;
+    type Synchronized<A> = Synchro.PSynchronized<never, never, never, never, A, A>;
 }
 /**
- * @tsplus type fncts.io.Ref
- * @tsplus companion fncts.io.RefOps
+ * @tsplus type fncts.io.RefOps
  */
-export declare abstract class Ref<A> {
-    readonly _typeId: RefTypeId;
-    _A: (_: A) => A;
+export interface RefOps {
+}
+export declare const Ref: RefOps;
+export interface ReadableRef<RB, EB, B> {
+    readonly [RefVariance]: {
+        readonly _RB: (_: never) => RB;
+        readonly _EB: (_: never) => EB;
+        readonly _B: (_: never) => B;
+    };
+    readonly get: IO<RB, EB, B>;
+}
+export interface WritableRef<RA, EA, A> {
+    readonly [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _EA: (_: never) => EA;
+        readonly _A: (_: A) => void;
+    };
+    set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+}
+export interface ModifiableRef<RA, RB, EA, EB, A, B> {
+    readonly [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
+}
+export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B>, ReadableRef<RB, EB, B>, WritableRef<RA, EA, A>, ModifiableRef<RA, RB, EA, EB, A, B> {
+    readonly [RefTypeId]: RefTypeId;
+    [RefVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    /**
+     * Folds over the error and value types of the `Ref`. This is a highly
+     * polymorphic method that is capable of arbitrarily transforming the error
+     * and value types of the `Ref`. For most use cases one of the more specific
+     * combinators implemented in terms of `match` will be more ergonomic but this
+     * method is extremely useful for implementing new combinators.
+     */
+    abstract match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA, RB, EC, ED, C, D>;
+    /**
+     * Folds over the error and value types ofthe `Ref`, allowing access to
+     * the state in transforming the `set` value. This is a more powerful version
+     * of `match` but requires unifying the error types.
+     */
+    abstract matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA | RB, RB, EC, ED, C, D>;
     /**
      * Reads the value from the `Ref`.
      */
-    abstract get: UIO<A>;
+    abstract get get(): IO<RB, EB, B>;
     /**
      * Writes a new value to the `Ref`, with a guarantee of immediate
      * consistency (at some cost to performance).
      */
-    abstract set(a: A, __tsplusTrace?: string): UIO<void>;
+    abstract set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
     /**
      * Atomically modifies the `Ref` with the specified function, which
      * computes a return value for the modification. This is a more powerful
      * version of `update`.
      */
-    abstract modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B>;
-    /**
-     * Atomically writes the specified value to the `Ref`, returning the value
-     * immediately before modification.
-     */
-    getAndSet(a: A, __tsplusTrace?: string): UIO<A>;
-    /**
-     * Atomically modifies the `Ref` with the specified function, returning the
-     * value immediately before modification.
-     */
-    getAndUpdate(f: (a: A) => A, __tsplusTrace?: string): UIO<A>;
-    /**
-     * Atomically modifies the `Ref` with the specified partial function,
-     * returning the value immediately before modification. If the function is
-     * undefined on the current value it doesn't change it.
-     */
-    getAndUpdateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A>;
-    /**
-     * Atomically modifies the `Ref` with the specified partial function, which
-     * computes a return value for the modification if the function is defined on
-     * the current value otherwise it returns a default value. This is a more
-     * powerful version of `updateJust`.
-     */
-    modifyJust<B>(orElse: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): UIO<B>;
-    /**
-     * Atomically modifies the `Ref` with the specified function.
-     */
-    update(f: (a: A) => A, __tsplusTrace?: string): UIO<void>;
-    /**
-     * Atomically modifies the `Ref` with the specified function and returns the
-     * updated value.
-     */
-    updateAndGet(f: (a: A) => A, __tsplusTrace?: string): UIO<A>;
-    /**
-     * Atomically modifies the `Ref` with the specified partial function. If the
-     * function is undefined on the current value it doesn't change it.
-     */
-    updateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<void>;
-    /**
-     * Atomically modifies the `Ref` with the specified partial function. If the
-     * function is undefined on the current value it returns the old value without
-     * changing it.
-     */
-    updateJustAndGet(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A>;
+    abstract modify<C>(f: (a: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
 }
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PRef<RA, RB, EA, EB, A, B>): asserts _ is RefInternal<RA, RB, EA, EB, A, B>;

package/Ref.d.ts

@@ -1,4 +1,10 @@
+export * from "./Ref/api.js";
 export * from "./Ref/Atomic.js";
 export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
+export * from "./Ref/Derived.js";
+export * from "./Ref/DerivedAll.js";
 export * from "./Ref/Synchronized.js";
+export * from "./Ref/Synchronized/api.js";
+export * from "./Ref/Synchronized/constructors.js";
+export * from "./Ref/Synchronized/definition.js";

package/RefSubject/Atomic.d.ts

@@ -0,0 +1,36 @@
+import { Just } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Emitter } from "@fncts/io/Push";
+import { Hold } from "@fncts/io/Push";
+import { Atomic } from "@fncts/io/Ref";
+import { RefSubjectInternal } from "@fncts/io/RefSubject";
+export declare class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
+    readonly initial: A;
+    readonly stream: Hold<never, E, A>;
+    readonly maybeRef: Atomic<import("@fncts/base/data/Maybe").Maybe<A>>;
+    readonly ref: AtomicEmitRef<E, A>;
+    constructor(initial: A);
+    get get(): import("../IO").UIO<A>;
+    set(value: A, __tsplusTrace?: string): import("../IO").IO<never, never, void>;
+    modify<E, A, B>(this: AtomicRefSubject<E, A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): IO<never, never, B>;
+    run<R>(emitter: Emitter<R, E, A>): IO<Scope | R, never, unknown>;
+    emit(value: A): IO<never, never, void>;
+    failCause(cause: Cause<E>): IO<never, never, void>;
+    end: IO<never, never, void>;
+    unsafeEmit(value: A): void;
+    unsafeFailCause(cause: Cause<E>): void;
+    unsafeEnd(): void;
+}
+declare class AtomicEmitRef<E, A> extends Atomic<A> {
+    readonly ref: Atomic<A>;
+    readonly emitter: Emitter<never, E, A>;
+    constructor(ref: Atomic<A>, emitter: Emitter<never, E, A>);
+    get get(): import("../IO").UIO<A>;
+    get unsafeGet(): A;
+    unsafeSet(value: A): void;
+    set(value: A, __tsplusTrace?: string): import("../IO").IO<never, never, void>;
+    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): import("../IO").IO<never, never, B>;
+}
+export {};

package/RefSubject/Synchronized/api.d.ts

@@ -0,0 +1,9 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { RefSubject } from "@fncts/io/RefSubject";
+/**
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps make
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps __call
+ * @tsplus location "@fncts/io/RefSubject/Synchronized/api"
+ */
+export declare function make<A>(initial: Lazy<A>): UIO<RefSubject.Synchronized<never, never, A, A>>;

package/RefSubject/Synchronized/definition.d.ts

@@ -0,0 +1,40 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import type { RefSubject } from "../definition.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { Emitter } from "@fncts/io/Push";
+import type { Scope } from "@fncts/io/Scope";
+import { IO } from "@fncts/io/IO";
+import { RefSubjectInternal } from "../definition.js";
+export declare const SynchronizedRefSubjectTypeId: unique symbol;
+export type SynchronizedRefSubjectTypeId = typeof SynchronizedRefSubjectTypeId;
+/**
+ * @tsplus type fncts.io.Push.RefSubject.Synchronized
+ */
+export interface SynchronizedRefSubject<R, E, A, B> extends RefSubject<R, E, A, B> {
+    readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId;
+}
+/**
+ * @tsplus type fncts.io.Push.RefSubject.SynchronizedOps
+ */
+export interface SynchronizedRefSubjectOps {
+}
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps Synchronized
+ * @tsplus location "@fncts/io/RefSubject/Synchronized/definition"
+ */
+export declare const Synchronized: SynchronizedRefSubjectOps;
+export declare class SynchronizedRefSubjectInternal<R, E, A, B> extends RefSubjectInternal<R, E, A, B> implements SynchronizedRefSubject<R, E, A, B> {
+    readonly semaphore: TSemaphore;
+    readonly ref: RefSubjectInternal<R, E, A, B>;
+    readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId;
+    constructor(semaphore: TSemaphore, ref: RefSubjectInternal<R, E, A, B>);
+    get get(): IO<R, never, B>;
+    set(a: A, __tsplusTrace?: string | undefined): IO<R, never, void>;
+    run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<R, never, C>;
+    modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<R | R1, E1, C>;
+    emit(value: A): IO<R, never, void>;
+    failCause(cause: Cause<E>): IO<R, never, void>;
+    end: IO<R, never, void>;
+    withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+}

package/RefSubject/api.d.ts

@@ -0,0 +1,116 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { RefSubject } from "./definition.js";
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps unsafeMake
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function unsafeMake<A>(initial: A): RefSubject<never, never, A, A>;
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps make
+ * @tsplus static fncts.io.Push.RefSubjectOps __call
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function make<A>(initial: Lazy<A>): UIO<RefSubject<never, never, A, A>>;
+/**
+ * Reads the value from the `Ref`.
+ * @tsplus getter fncts.io.Push.RefSubject get
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function get<R, E, A, B>(self: RefSubject<R, E, A, B>, __tsplusTrace?: string): IO<R, never, B>;
+/**
+ * Writes a new value to the `Ref`, with a guarantee of immediate
+ * consistency (at some cost to performance).
+ * @tsplus pipeable fncts.io.Push.RefSubject set
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function set<A>(a: A, __tsplusTrace?: string): <R, E, B>(self: RefSubject<R, E, A, B>) => import("../IO.js").IO<R, never, void>;
+/**
+ * Transforms both the `set` and `get` values of the `Ref` with the
+ * specified functions.
+ * @tsplus pipeable fncts.io.Push.RefSubject dimap
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function dimap<A, B, C, D>(f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, B>) => RefSubject<R, E, C, D>;
+/**
+ * Transforms the `set` value of the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Push.RefSubject contramap
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function contramap<A, C>(f: (_: C) => A, __tsplusTrace?: string): <R, E, B>(self: RefSubject<R, E, A, B>) => RefSubject<R, E, C, B>;
+/**
+ * Transforms the `get` value of the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Push.RefSubject map
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function map<B, C>(f: (_: B) => C, __tsplusTrace?: string): <R, E, A>(ref: RefSubject<R, E, A, B>) => RefSubject<R, E, A, C>;
+/**
+ * Atomically modifies the `Ref` with the specified function, which
+ * computes a return value for the modification. This is a more powerful
+ * version of `update`.
+ * @tsplus pipeable fncts.io.Push.RefSubject modify
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, B>;
+/**
+ * Atomically modifies the `Ref` with the specified partial function,
+ * which computes a return value for the modification if the function is
+ * defined on the current value otherwise it returns a default value. This
+ * is a more powerful version of `updateJust`.
+ * @tsplus pipeable fncts.io.Push.RefSubject modifyJust
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, B>;
+/**
+ * Atomically writes the specified value to the `Ref`, returning the value
+ * immediately before modification.
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndSet
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+/**
+ * Atomically modifies the `Ref` with the specified function, returning
+ * the value immediately before modification.
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndUpdate
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, E, A>;
+/**
+ * Atomically modifies the `Ref` with the specified partial function,
+ * returning the value immediately before modification. If the function is
+ * undefined on the current value it doesn't change it.
+ * @tsplus pipeable fncts.io.Push.RefSubject getAndUpdateJust
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+/**
+ * Atomically modifies the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Push.RefSubject update
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, void>;
+/**
+ * Atomically modifies the `Ref` with the specified function and returns
+ * the updated value.
+ * @tsplus pipeable fncts.io.Push.RefSubject updateAndGet
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;
+/**
+ * Atomically modifies the `Ref` with the specified partial function. If
+ * the function is undefined on the current value it doesn't change it.
+ * @tsplus pipeable fncts.io.Push.RefSubject updateJust
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, void>;
+/**
+ * Atomically modifies the `Ref` with the specified partial function. If
+ * the function is undefined on the current value it returns the old value
+ * without changing it.
+ * @tsplus pipeable fncts.io.Push.RefSubject updateJustAndGet
+ * @tsplus location "@fncts/io/RefSubject/api"
+ */
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <R, E>(self: RefSubject<R, E, A, A>) => import("../IO.js").IO<R, never, A>;

package/RefSubject/definition.d.ts

@@ -0,0 +1,51 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Emitter } from "../Push.js";
+import type { Push } from "../Push.js";
+import type { ModifiableRef, ReadableRef, WritableRef } from "../Ref.js";
+import type { SynchronizedRefSubject } from "@fncts/io/RefSubject/Synchronized/definition";
+import { PushTypeId } from "../Push.js";
+import { PushVariance } from "../Push.js";
+import { RefVariance } from "../Ref.js";
+/**
+ * @tsplus type fncts.io.Push.RefSubject
+ */
+export interface RefSubject<out R, in out E, in A, out B> extends Push<R, E, B>, Emitter<R, E, A> {
+}
+/**
+ * @tsplus type fncts.io.Push.RefSubjectOps
+ */
+export interface RefSubjectOps {
+}
+export declare const RefSubject: RefSubjectOps;
+export declare namespace RefSubject {
+    type Synchronized<R, E, A, B> = SynchronizedRefSubject<R, E, A, B>;
+}
+export declare abstract class RefSubjectInternal<R, E, A, B> implements ReadableRef<R, never, B>, WritableRef<R, never, A>, ModifiableRef<R, R, never, never, A, B>, Push<R, E, B>, Emitter<R, E, A> {
+    readonly [PushTypeId]: PushTypeId;
+    [RefVariance]: {
+        readonly _RA: (_: never) => R;
+        readonly _RB: (_: never) => R;
+        readonly _EA: (_: never) => never;
+        readonly _EB: (_: never) => never;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
+    [PushVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: A) => B;
+    };
+    abstract get get(): IO<R, never, B>;
+    abstract set(value: A): IO<R, never, void>;
+    abstract modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<R, never, C>;
+    abstract run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void>;
+    abstract failCause(cause: Cause<E>): IO<R, never, void>;
+    abstract emit(value: A): IO<R, never, void>;
+    abstract end: IO<R, never, void>;
+}
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<R, E, A, B>(_: RefSubject<R, E, A, B>): asserts _ is RefSubjectInternal<R, E, A, B>;

package/RefSubject.d.ts

@@ -0,0 +1,3 @@
+export * from "./RefSubject/api.js";
+export * from "./RefSubject/Atomic.js";
+export * from "./RefSubject/definition.js";

package/Reloadable/definition.d.ts

@@ -1,6 +1,8 @@
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
 import { IO, UIO } from "@fncts/io/IO/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
+export declare const ReloadableVariance: unique symbol;
+export type ReloadableVariance = typeof ReloadableVariance;
 /**
  * @tsplus type fncts.io.Reloadable
  * @tsplus companion fncts.io.ReloadableOps
@@ -8,7 +10,9 @@ import { Tag } from "@fncts/base/data/Tag/definition";
 export declare class Reloadable<Service> {
     readonly scopedRef: ScopedRef<Service>;
     readonly reload: IO<never, unknown, void>;
-    _Service: (_: never) => Service;
+    [ReloadableVariance]: {
+        readonly _Service: (_: never) => Service;
+    };
     constructor(scopedRef: ScopedRef<Service>, reload: IO<never, unknown, void>);
     get get(): UIO<Service>;
     get reloadFork(): UIO<void>;

package/RuntimeConfig.d.ts

@@ -2,34 +2,10 @@ import { CaseClass } from "@fncts/base/data/CaseClass";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Supervisor } from "@fncts/io/Supervisor/definition";
 import { Logger } from "@fncts/io/Logger/definition";
-import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
-export declare const RuntimeConfigFlag: {
-    readonly EnableCurrentFiber: symbol;
-    readonly LogRuntime: symbol;
-    readonly SuperviseOperations: symbol;
-    readonly TrackRuntimeMetrics: symbol;
-    readonly EnableFiberRoots: symbol;
-};
-export type RuntimeConfigFlag = typeof RuntimeConfigFlag[keyof typeof RuntimeConfigFlag];
 export declare class RuntimeConfig extends CaseClass<{
     readonly reportFailure: (e: Cause<unknown>) => void;
     readonly supervisor: Supervisor<any>;
-    readonly flags: RuntimeConfigFlags;
     readonly yieldOpCount: number;
     readonly logger: Logger<string, any>;
 }> {
 }
-/**
- * @tsplus companion fncts.RuntimeConfigFlags
- */
-export declare class RuntimeConfigFlags {
-    readonly flags: HashSet<RuntimeConfigFlag>;
-    constructor(flags: HashSet<RuntimeConfigFlag>);
-    add(flag: RuntimeConfigFlag): RuntimeConfigFlags;
-    isEnabled(flag: RuntimeConfigFlag): boolean;
-}
-/**
- * @tsplus static fncts.RuntimeConfigFlags empty
- * @tsplus location "@fncts/io/RuntimeConfig"
- */
-export declare const empty: RuntimeConfigFlags;

package/RuntimeFlag.d.ts

@@ -0,0 +1,10 @@
+export declare const enum RuntimeFlag {
+    Interruption = 1,
+    CurrentFiber = 2,
+    OpLog = 4,
+    OpSupervision = 8,
+    RuntimeMetrics = 16,
+    FiberRoots = 32,
+    WindDown = 64,
+    CooperativeYielding = 128
+}

package/RuntimeFlags/Patch.d.ts

@@ -0,0 +1,53 @@
+import type { RuntimeFlag } from "../RuntimeFlag.js";
+import { RuntimeFlags } from "./RuntimeFlags.js";
+/**
+ * @tsplus type fncts.io.RuntimeFlagsPatch
+ */
+export type RuntimeFlagsPatch = number & {
+    readonly RuntimeFlagsPatch: unique symbol;
+};
+/**
+ * @tsplus type fncts.io.RuntimeFlagsPatchOps
+ */
+export interface RuntimeFlagsPatchOps {
+}
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps Patch
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare const RuntimeFlagsPatch: RuntimeFlagsPatchOps;
+/**
+ * @tsplus static fncts.io.RuntimeFlagsPatchOps __call
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare function makeRuntimeFlagsPatch(active: number, enabled: number): RuntimeFlags.Patch;
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps enable
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare function mkEnable(flag: RuntimeFlag): RuntimeFlags.Patch;
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps disable
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare function mkDisable(flag: RuntimeFlag): RuntimeFlags.Patch;
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch isActive
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare function isActive(patch: RuntimeFlags.Patch, flag: RuntimeFlag): boolean;
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch isEnabled
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare function isEnabledPatch(patch: RuntimeFlags.Patch, flag: RuntimeFlag): boolean;
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch patch
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare function patch(patch: RuntimeFlags.Patch, flags: RuntimeFlags): RuntimeFlags;
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch exclude
+ * @tsplus location "@fncts/io/RuntimeFlags/Patch"
+ */
+export declare function exclude(patch: RuntimeFlags.Patch, flag: RuntimeFlag): RuntimeFlags.Patch;

package/RuntimeFlags/RuntimeFlags.d.ts

@@ -0,0 +1,82 @@
+import type { RuntimeFlagsPatch } from "./Patch.js";
+import { RuntimeFlag } from "../RuntimeFlag.js";
+/**
+ * @tsplus type fncts.io.RuntimeFlags
+ */
+export type RuntimeFlags = number & {
+    readonly RuntimeFlags: unique symbol;
+};
+/**
+ * @tsplus type fncts.io.RuntimeFlagsOps
+ */
+export interface RuntimeFlagsOps {
+}
+export declare const RuntimeFlags: RuntimeFlagsOps;
+export declare namespace RuntimeFlags {
+    type Patch = RuntimeFlagsPatch;
+}
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps __call
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function makeRuntimeFlags(...flags: ReadonlyArray<RuntimeFlag>): RuntimeFlags;
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags isEnabled
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function isEnabled(flags: RuntimeFlags, flag: RuntimeFlag): boolean;
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags enable
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function enable(flags: RuntimeFlags, flag: RuntimeFlag): RuntimeFlags;
+/**
+ * @tsplus getter fncts.io.RuntimeFlags cooperativeYielding
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function cooperativeYielding(flags: RuntimeFlags): boolean;
+/**
+ * @tsplus getter fncts.io.RuntimeFlags currentFiber
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function currentFiber(flags: RuntimeFlags): boolean;
+/**
+ * @tsplus getter fncts.io.RuntimeFlags fiberRoots
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function fiberRoots(flags: RuntimeFlags): boolean;
+/**
+ * @tsplus getter fncts.io.RuntimeFlags interruption
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function interruption(flags: RuntimeFlags): boolean;
+/**
+ * @tsplus getter fncts.io.RuntimeFlags windDown
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function windDown(flags: RuntimeFlags): boolean;
+/**
+ * @tsplus getter fncts.io.RuntimeFlags opSupervision
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function opSpervision(flags: RuntimeFlags): boolean;
+/**
+ * @tsplus getter fncts.io.RuntimeFlags interruptible
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function interruptible(flags: RuntimeFlags): boolean;
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags diff
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare function diff(oldValue: RuntimeFlags, newValue: RuntimeFlags): RuntimeFlagsPatch;
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps none
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare const none: RuntimeFlags;
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps default
+ * @tsplus location "@fncts/io/RuntimeFlags/RuntimeFlags"
+ */
+export declare const defaultRuntimeFlags: RuntimeFlags;

package/RuntimeFlags.d.ts

@@ -0,0 +1,2 @@
+export * from "./RuntimeFlags/Patch.js";
+export * from "./RuntimeFlags/RuntimeFlags.js";

package/STM/api/atomically.d.ts

@@ -0,0 +1,9 @@
+import { STM } from "@fncts/io/STM/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+/**
+ * @tsplus static fncts.io.STMOps atomically
+ * @tsplus getter fncts.io.STM commit
+ * @tsplus location "@fncts/io/STM/api/atomically"
+ */
+export declare function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;