@fncts/io 0.0.21 → 0.0.22

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,45 @@
+import { Ref } from "@fncts/io/Ref/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 "../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";
+/**
+ * @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> {
+    readonly _A: (_: A) => B;
+}
+/**
+ * @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> {
+    [Ref._RA]: () => R;
+    [Ref._RB]: () => R;
+    [Ref._EA]: () => never;
+    [Ref._EB]: () => never;
+    [Ref._A]: (_: A) => void;
+    [Ref._B]: () => B;
+    _R: (_: never) => R;
+    _E: (_: never) => E;
+    _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/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/Schedule/api.d.ts

@@ -1,5 +1,6 @@
 import { IO, URIO, UIO } from "@fncts/io/IO/definition";
 import { Schedule } from "@fncts/io/Schedule/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
@@ -18,12 +19,12 @@ export declare function make<State, Env, In, Out>(initial: State, step: (now: nu
  * @tsplus pipeable fncts.io.Schedule addDelay
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function addDelay<Out>(f: (out: Out) => number, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out>;
+export declare function addDelay<Out>(f: (out: Out) => Duration, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out>;
 /**
  * @tsplus pipeable fncts.io.Schedule addDelayIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, number>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
+export declare function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
 /**
  * @tsplus pipeable fncts.io.Schedule andThen
  * @tsplus location "@fncts/io/Schedule/api"
@@ -39,6 +40,11 @@ export declare function andThenEither<State1, Env1, In1, Out1>(that: Schedule.Wi
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function as<Out2>(out2: Lazy<Out2>, __tsplusTrace?: string): <State, Env, In, Out>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out2>;
+/**
+ * @tsplus getter fncts.io.Schedule asUnit
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare function asUnit<State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>): Schedule.WithState<State, Env, In, void>;
 /**
  * @tsplus pipeable fncts.io.Schedule check
  * @tsplus location "@fncts/io/Schedule/api"
@@ -73,17 +79,17 @@ export declare function contramapIO<I, R1, I2>(f: (inp: I2) => URIO<R1, I>, __ts
  * @tsplus static fncts.io.ScheduleOps delayed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, number>, __tsplusTrace?: string): Schedule.WithState<S, R, I, number>;
+export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, Duration>, __tsplusTrace?: string): Schedule.WithState<S, R, I, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule delayed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayedSelf(f: (delay: number) => number, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
+export declare function delayedSelf(f: (delay: Duration) => Duration, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule delayedIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function delayedIO<R1>(f: (delay: number) => URIO<R1, number>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function delayedIO<R1>(f: (delay: Duration) => URIO<R1, Duration>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
 /**
  * @tsplus getter fncts.io.Schedule delays
  * @tsplus location "@fncts/io/Schedule/api"
@@ -103,7 +109,7 @@ export declare function dimapIO<I, O, R1, I2, R2, O2>(f: (inp2: I2) => URIO<R1,
  * @tsplus static fncts.io.ScheduleOps duration
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function duration(duration: number, __tsplusTrace?: string): Schedule.WithState<boolean, never, unknown, number>;
+export declare function duration(duration: Duration, __tsplusTrace?: string): Schedule.WithState<boolean, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule either
  * @tsplus pipeable-operator fncts.io.Schedule ||
@@ -119,7 +125,7 @@ export declare function eitherWith<O, S1, R1, I1, O1, O2>(that: Schedule.WithSta
  * @tsplus static fncts.io.ScheduleOps elapsed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, number>;
+export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule ensuring
  * @tsplus location "@fncts/io/Schedule/api"
@@ -129,7 +135,7 @@ export declare function ensuring(finalizer: UIO<any>, __tsplusTrace?: string): <
  * @tsplus static fncts.io.ScheduleOps exponential
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function exponential(base: number, factor?: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function exponential(base: Duration, factor?: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration>;
 /**
  * A schedule that recurs on a fixed interval. Returns the number of
  * repetitions of the schedule so far.
@@ -144,7 +150,7 @@ export declare function exponential(base: number, factor?: number, __tsplusTrace
  * @tsplus static fncts.io.ScheduleOps fixed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function fixed(interval: number, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
+export declare function fixed(interval: Duration, __tsplusTrace?: string): Schedule.WithState<readonly [Maybe<readonly [number, number]>, number], never, unknown, number>;
 /**
  * @tsplus pipeable fncts.io.Schedule fold
  * @tsplus location "@fncts/io/Schedule/api"
@@ -179,7 +185,7 @@ export declare function intersectWith<S1, R1, I1, O1>(that: Schedule.WithState<S
  * @tsplus static fncts.io.Schedule linear
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function linear(base: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function linear(base: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule map
  * @tsplus location "@fncts/io/Schedule/api"
@@ -194,7 +200,17 @@ export declare function mapIO<Out, Env1, Out1>(f: (out: Out) => URIO<Env1, Out1>
  * @tsplus pipeable fncts.io.Schedule modifyDelayIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function modifyDelayIO<Out, Env1>(f: (out: Out, duration: number) => URIO<Env1, number>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
+export declare function modifyDelayIO<Out, Env1>(f: (out: Out, duration: Duration) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
+/**
+ * @tsplus static fncts.io.ScheduleOps once
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare const once: Schedule.WithState<number, never, any, void>;
+/**
+ * @tsplus static fncts.io.ScheduleOps asap
+ * @tsplus location "@fncts/io/Schedule/api"
+ */
+export declare const asap: import("./definition.js").Schedule.WithState<number, never, any, void>;
 /**
  * @tsplus pipeable fncts.io.Schedule onDecision
  * @tsplus location "@fncts/io/Schedule/api"
@@ -216,17 +232,17 @@ export declare function reconsider<S, O, O2>(f: (state: S, out: O, decision: Dec
  */
 export declare function reconsiderIO<S, O, R1, O1>(f: (state: S, out: O, decision: Decision) => URIO<R1, Either<O1, readonly [O1, Interval]>>, __tsplusTrace?: string): <R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O1>;
 /**
- * @tsplus static fncts.io.Schedule recurs
+ * @tsplus static fncts.io.ScheduleOps recurs
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurs(n: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
- * @tsplus static fncts.io.Schedule recurWhile
+ * @tsplus static fncts.io.ScheduleOps recurWhile
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurWhile<A>(f: (a: A) => boolean, __tsplusTrace?: string): Schedule.WithState<void, never, A, A>;
 /**
- * @tsplus static fncts.io.Schedule recurWhileIO
+ * @tsplus static fncts.io.ScheduleOps recurWhileIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
 export declare function recurWhileIO<R, A>(f: (a: A) => URIO<R, boolean>, __tsplusTrace?: string): Schedule.WithState<void, R, A, A>;
@@ -259,7 +275,7 @@ export declare function repetitions<S, R, I, O>(self: Schedule.WithState<S, R, I
  * @tsplus pipeable fncts.io.Schedule resetAfter
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function resetAfter(duration: number, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, import("@fncts/base/data/Maybe.js").Maybe<number>], R, I, O>;
+export declare function resetAfter(duration: Duration, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, import("@fncts/base/data/Maybe.js").Maybe<number>], R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule resetWhen
  * @tsplus location "@fncts/io/Schedule/api"
@@ -274,7 +290,7 @@ export declare function run<I>(now: number, input: Iterable<I>, __tsplusTrace?:
  * @tsplus static fncts.io.Schedule spaced
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function spaced(duration: number, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
+export declare function spaced(duration: Duration, __tsplusTrace?: string): Schedule.WithState<number, never, unknown, number>;
 /**
  * @tsplus static fncts.io.Schedule succeed
  * @tsplus location "@fncts/io/Schedule/api"
@@ -324,7 +340,7 @@ export declare function untilOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, _
  * @tsplus static fncts.io.Schedule upTo
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function upTo(duration: number, __tsplusTrace?: string): Schedule.WithState<Maybe<number>, never, unknown, number>;
+export declare function upTo(duration: Duration, __tsplusTrace?: string): Schedule.WithState<Maybe<number>, never, unknown, Duration>;
 /**
  * @tsplus pipeable fncts.io.Schedule whileInput
  * @tsplus location "@fncts/io/Schedule/api"

package/Scope/ReleaseMap/definition.d.ts

@@ -3,7 +3,7 @@ import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype } from "@fncts/base/data/Newtype";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 export declare class Exited {
     readonly nextKey: number;
     readonly exit: Exit<any, any>;

package/ScopedRef/api.d.ts

@@ -1,7 +1,7 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { ScopedRef } from "@fncts/io/ScopedRef/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 /**
  * @tsplus static fncts.io.ScopedRefOps fromAcquire

package/Sink/api.d.ts

@@ -9,37 +9,37 @@ import { Cause } from "@fncts/base/data/Cause/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Enqueue } from "@fncts/io/Queue/definition";
+import { Queue } from "@fncts/io/Queue/definition";
 import { Hub } from "@fncts/io/Hub/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Duration } from "@fncts/base/data/Duration/definition";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 /**
  * Like {@link zip }, but keeps only the result from this sink
- * @tsplus pipeable fncts.io.Sink apFirst
+ * @tsplus pipeable fncts.io.Sink zipLeft
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirst<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
+export declare function zipLeft<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
 /**
  * Like {@link zipC }, but keeps only the result from this sink
- * @tsplus pipeable fncts.io.Sink apFirstC
+ * @tsplus pipeable fncts.io.Sink zipLeftC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apFirstC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
+export declare function zipLeftC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z_1>;
 /**
  * Like {@link zip }, but keeps only the result from the `that` sink
- * @tsplus pipeable fncts.io.Sink apSecond
+ * @tsplus pipeable fncts.io.Sink zipRight
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecond<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
+export declare function zipRight<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
 /**
  * Like {@link zipC }, but keeps only the result from the `that` sink
- * @tsplus pipeable fncts.io.Sink apSecondC
+ * @tsplus pipeable fncts.io.Sink zipRightC
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function apSecondC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
+export declare function zipRightC<In, L, R1, E1, In1 extends In, L1 extends L, Z1>(that: Lazy<Sink<R1, E1, In1, L1, Z1>>, __tsplusTrace?: string): <R, E, Z_1>(self: import("./definition.js").Sink<R, E, In, L, Z_1>) => import("./definition.js").Sink<R1 | R, E1 | E, In & In1, L | L1, Z1>;
 /**
  * Replaces this sink's result with the provided value.
  * @tsplus pipeable fncts.io.Sink as
@@ -252,14 +252,14 @@ export declare function fromPush<R, E, In, L, Z, R1>(push: IO<R, never, (_: Mayb
  * @tsplus static fncts.io.SinkOps fromQueue
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueue<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
+export declare function fromQueue<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which enqueues each element into the specified queue. The
  * queue will be shutdown once the stream is closed.
  * @tsplus static fncts.io.SinkOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Sink/api"
  */
-export declare function fromQueueWithShutdown<In>(queue: Lazy<Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
+export declare function fromQueueWithShutdown<In>(queue: Lazy<Queue.Enqueue<In>>, __tsplusTrace?: string): Sink<never, never, In, never, void>;
 /**
  * Create a sink which publishes each element to the specified hub.
  * @tsplus static fncts.io.SinkOps fromHub