@fncts/io 0.0.38 → 0.0.40

package/Schedule/api.d.ts

@@ -19,27 +19,27 @@ 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) => 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>;
+export declare function addDelay<Out>(f: (out: Out) => Duration, __tsplusTrace?: string): <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>) => 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, 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>;
+export declare function addDelayIO<Out, Env1>(f: (out: Out) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<State, Env | Env1, In, Out>;
 /**
  * @tsplus pipeable fncts.io.Schedule andThen
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function andThen<State1, Env1, In1, Out1>(that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): <State, Env, In, Out>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<readonly [State, State1, boolean], Env1 | Env, In & In1, Out1 | Out>;
+export declare function andThen<State1, Env1, In1, Out1>(that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): <State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Out | Out1>;
 /**
  * @tsplus pipeable fncts.io.Schedule andThenEither
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function andThenEither<State1, Env1, In1, Out1>(that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): <State, Env, In, Out>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<readonly [State, State1, boolean], Env1 | Env, In & In1, import("@fncts/base/data/Either.js").Either<Out, Out1>>;
+export declare function andThenEither<State1, Env1, In1, Out1>(that: Schedule.WithState<State1, Env1, In1, Out1>, __tsplusTrace?: string): <State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<readonly [State, State1, boolean], Env | Env1, In & In1, Either<Out, Out1>>;
 /**
  * @tsplus pipeable fncts.io.Schedule as
  * @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>;
+export declare function as<Out2>(out2: Lazy<Out2>, __tsplusTrace?: string): <State, Env, In, Out>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<State, Env, In, Out2>;
 /**
  * @tsplus getter fncts.io.Schedule asUnit
  * @tsplus location "@fncts/io/Schedule/api"
@@ -49,32 +49,32 @@ export declare function asUnit<State, Env, In, Out>(self: Schedule.WithState<Sta
  * @tsplus pipeable fncts.io.Schedule check
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function check<In, Out>(test: (inp: In, out: Out) => boolean, __tsplusTrace?: string): <State, Env>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out>;
+export declare function check<In, Out>(test: (inp: In, out: Out) => boolean, __tsplusTrace?: string): <State, Env>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<State, Env, In, Out>;
 /**
  * @tsplus pipeable fncts.io.Schedule checkIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function checkIO<In, Out, Env1>(test: (inp: In, out: Out) => URIO<Env1, boolean>, __tsplusTrace?: string): <State, Env>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out>;
+export declare function checkIO<In, Out, Env1>(test: (inp: In, out: Out) => URIO<Env1, boolean>, __tsplusTrace?: string): <State, Env>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<State, Env | Env1, In, Out>;
 /**
  * @tsplus pipeable fncts.io.Schedule compose
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function compose<O, S1, R1, O2>(that: Schedule.WithState<S1, R1, O, O2>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I, O2>;
+export declare function compose<O, S1, R1, O2>(that: Schedule.WithState<S1, R1, O, O2>, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I, O2>;
 /**
  * @tsplus pipeable fncts.io.Schedule contramap
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function contramap<I, I2>(f: (inp: I2) => I, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I2, O>;
+export declare function contramap<I, I2>(f: (inp: I2) => I, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I2, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule contramapEnvironment
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function contramapEnvironment<R, R1>(f: (env: Environment<R1>) => Environment<R>, __tsplusTrace?: string): <S, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1, I, O>;
+export declare function contramapEnvironment<R, R1>(f: (env: Environment<R1>) => Environment<R>, __tsplusTrace?: string): <S, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R1, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule contramapIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function contramapIO<I, R1, I2>(f: (inp: I2) => URIO<R1, I>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I2, O>;
+export declare function contramapIO<I, R1, I2>(f: (inp: I2) => URIO<R1, I>, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I2, O>;
 /**
  * @tsplus static fncts.io.ScheduleOps delayed
  * @tsplus location "@fncts/io/Schedule/api"
@@ -84,12 +84,12 @@ export declare function delayed<S, R, I>(schedule: Schedule.WithState<S, R, I, D
  * @tsplus pipeable fncts.io.Schedule delayed
  * @tsplus location "@fncts/io/Schedule/api"
  */
-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>;
+export declare function delayedSelf(f: (delay: Duration) => Duration, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => 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: 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>;
+export declare function delayedIO<R1>(f: (delay: Duration) => URIO<R1, Duration>, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus getter fncts.io.Schedule delays
  * @tsplus location "@fncts/io/Schedule/api"
@@ -99,12 +99,12 @@ export declare function delays<S, R, I, O>(self: Schedule.WithState<S, R, I, O>,
  * @tsplus pipeable fncts.io.Schedule dimap
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function dimap<I, O, I2, O2>(f: (inp2: I2) => I, g: (out: O) => O2, __tsplusTrace?: string): <S, R>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I2, O2>;
+export declare function dimap<I, O, I2, O2>(f: (inp2: I2) => I, g: (out: O) => O2, __tsplusTrace?: string): <S, R>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I2, O2>;
 /**
  * @tsplus pipeable fncts.io.Schedule dimapIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function dimapIO<I, O, R1, I2, R2, O2>(f: (inp2: I2) => URIO<R1, I>, g: (out: O) => URIO<R2, O2>, __tsplusTrace?: string): <S, R>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R2 | R, I2, O2>;
+export declare function dimapIO<I, O, R1, I2, R2, O2>(f: (inp2: I2) => URIO<R1, I>, g: (out: O) => URIO<R2, O2>, __tsplusTrace?: string): <S, R>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1 | R2, I2, O2>;
 /**
  * @tsplus static fncts.io.ScheduleOps duration
  * @tsplus location "@fncts/io/Schedule/api"
@@ -115,12 +115,12 @@ export declare function duration(duration: Duration, __tsplusTrace?: string): Sc
  * @tsplus pipeable-operator fncts.io.Schedule ||
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function either<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, readonly [O, O1]>;
+export declare function either<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
 /**
  * @tsplus pipeable fncts.io.Schedule eitherWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function eitherWith<O, S1, R1, I1, O1, O2>(that: Schedule.WithState<S1, R1, I1, O1>, f: (out1: O, out2: O1) => O2, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O2>;
+export declare function eitherWith<O, S1, R1, I1, O1, O2>(that: Schedule.WithState<S1, R1, I1, O1>, f: (out1: O, out2: O1) => O2, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, O2>;
 /**
  * @tsplus static fncts.io.ScheduleOps elapsed
  * @tsplus location "@fncts/io/Schedule/api"
@@ -130,7 +130,7 @@ export declare const elapsed: Schedule.WithState<Maybe<number>, never, unknown,
  * @tsplus pipeable fncts.io.Schedule ensuring
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function ensuring(finalizer: UIO<any>, __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 ensuring(finalizer: UIO<any>, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus static fncts.io.ScheduleOps exponential
  * @tsplus location "@fncts/io/Schedule/api"
@@ -155,12 +155,12 @@ export declare function fixed(interval: Duration, __tsplusTrace?: string): Sched
  * @tsplus pipeable fncts.io.Schedule fold
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function fold<O, Z>(z: Z, f: (z: Z, out: O) => Z, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, Z], R, I, Z>;
+export declare function fold<O, Z>(z: Z, f: (z: Z, out: O) => Z, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, Z], R, I, Z>;
 /**
  * @tsplus pipeable fncts.io.Schedule foldIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function foldIO<O, Z, R1>(z: Z, f: (z: Z, out: O) => URIO<R1, Z>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, Z], R1 | R, I, Z>;
+export declare function foldIO<O, Z, R1>(z: Z, f: (z: Z, out: O) => URIO<R1, Z>, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, Z], R | R1, I, Z>;
 /**
  * @tsplus getter fncts.io.Schedule forever
  * @tsplus location "@fncts/io/Schedule/api"
@@ -180,7 +180,7 @@ export declare function identity<A>(__tsplusTrace?: string): Schedule.WithState<
  * @tsplus pipeable fncts.io.Schedule intersectWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function intersectWith<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, readonly [O, O1]>;
+export declare function intersectWith<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
 /**
  * @tsplus static fncts.io.Schedule linear
  * @tsplus location "@fncts/io/Schedule/api"
@@ -190,17 +190,17 @@ export declare function linear(base: Duration, __tsplusTrace?: string): Schedule
  * @tsplus pipeable fncts.io.Schedule map
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function map<Out, Out1>(f: (out: Out) => Out1, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env, In, Out1>;
+export declare function map<Out, Out1>(f: (out: Out) => Out1, __tsplusTrace?: string): <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<State, Env, In, Out1>;
 /**
  * @tsplus pipeable fncts.io.Schedule mapIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function mapIO<Out, Env1, Out1>(f: (out: Out) => URIO<Env1, Out1>, __tsplusTrace?: string): <State, Env, In>(self: import("./definition.js").Schedule.WithState<State, Env, In, Out>) => import("./definition.js").Schedule.WithState<State, Env1 | Env, In, Out1>;
+export declare function mapIO<Out, Env1, Out1>(f: (out: Out) => URIO<Env1, Out1>, __tsplusTrace?: string): <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<State, Env | Env1, In, Out1>;
 /**
  * @tsplus pipeable fncts.io.Schedule modifyDelayIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-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>;
+export declare function modifyDelayIO<Out, Env1>(f: (out: Out, duration: Duration) => URIO<Env1, Duration>, __tsplusTrace?: string): <State, Env, In>(self: Schedule.WithState<State, Env, In, Out>) => Schedule.WithState<State, Env | Env1, In, Out>;
 /**
  * @tsplus static fncts.io.ScheduleOps once
  * @tsplus location "@fncts/io/Schedule/api"
@@ -215,22 +215,22 @@ export declare const asap: import("./definition.js").Schedule.WithState<number,
  * @tsplus pipeable fncts.io.Schedule onDecision
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function onDecision<S, O, R1>(f: (state: S, out: O, decision: Decision) => URIO<R1, any>, __tsplusTrace?: string): <R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function onDecision<S, O, R1>(f: (state: S, out: O, decision: Decision) => URIO<R1, any>, __tsplusTrace?: string): <R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule provideEnvironment
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function provideEnvironment<R>(env: Environment<R>, __tsplusTrace?: string): <S, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, never, I, O>;
+export declare function provideEnvironment<R>(env: Environment<R>, __tsplusTrace?: string): <S, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, never, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule reconsider
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function reconsider<S, O, O2>(f: (state: S, out: O, decision: Decision) => Either<O2, readonly [O2, Interval]>, __tsplusTrace?: string): <R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O2>;
+export declare function reconsider<S, O, O2>(f: (state: S, out: O, decision: Decision) => Either<O2, readonly [O2, Interval]>, __tsplusTrace?: string): <R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I, O2>;
 /**
  * @tsplus pipeable fncts.io.Schedule reconsiderIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-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>;
+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: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O1>;
 /**
  * @tsplus static fncts.io.ScheduleOps recurs
  * @tsplus location "@fncts/io/Schedule/api"
@@ -275,17 +275,17 @@ 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: 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>;
+export declare function resetAfter(duration: Duration, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, Maybe<number>], R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule resetWhen
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function resetWhen<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
+export declare function resetWhen<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule run
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function run<I>(now: number, input: Iterable<I>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("../IO.js").URIO<R, import("@fncts/base/collection/immutable/Conc.js").Conc<O>>;
+export declare function run<I>(now: number, input: Iterable<I>, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => import("../IO.js").URIO<R, import("@fncts/base/collection/immutable/Conc.js").Conc<O>>;
 /**
  * @tsplus static fncts.io.Schedule spaced
  * @tsplus location "@fncts/io/Schedule/api"
@@ -300,17 +300,17 @@ export declare function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Schedule
  * @tsplus pipeable fncts.io.Schedule tapInput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function tapInput<I, R1>(f: (inp: I) => URIO<R1, any>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function tapInput<I, R1>(f: (inp: I) => URIO<R1, any>, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule tapOutput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function tapOutput<O, R1>(f: (out: O) => URIO<R1, any>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function tapOutput<O, R1>(f: (out: O) => URIO<R1, any>, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule unionWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function unionWith<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, readonly [O, O1]>;
+export declare function unionWith<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, f: (int1: Intervals, int2: Intervals) => Intervals, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
 /**
  * @tsplus static fncts.io.ScheduleOps unfold
  * @tsplus location "@fncts/io/Schedule/api"
@@ -320,22 +320,22 @@ export declare function unfold<A>(a: Lazy<A>, f: (a: A) => A, __tsplusTrace?: st
  * @tsplus pipeable fncts.io.Schedule untilInput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
+export declare function untilInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule untilInputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function untilInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule untilOutput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
+export declare function untilOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule untilOutputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function untilOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function untilOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus static fncts.io.Schedule upTo
  * @tsplus location "@fncts/io/Schedule/api"
@@ -345,22 +345,22 @@ export declare function upTo(duration: Duration, __tsplusTrace?: string): Schedu
  * @tsplus pipeable fncts.io.Schedule whileInput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
+export declare function whileInput<I>(f: (inp: I) => boolean, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule whileInputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function whileInputIO<I, R1>(f: (inp: I) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule whileOutput
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R, I, O>;
+export declare function whileOutput<O>(f: (out: O) => boolean, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R, I, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule whileOutputIO
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function whileOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<S, R1 | R, I, O>;
+export declare function whileOutputIO<O, R1>(f: (out: O) => URIO<R1, boolean>, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<S, R | R1, I, O>;
 /**
  * @tsplus static fncts.io.Schedule windowed
  * @tsplus location "@fncts/io/Schedule/api"
@@ -370,19 +370,19 @@ export declare function windowed(interval: number, __tsplusTrace?: string): Sche
  * @tsplus pipeable fncts.io.Schedule zip
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zip<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, readonly [O, O1]>;
+export declare function zip<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, readonly [O, O1]>;
 /**
  * @tsplus pipeable fncts.io.Schedule zipLeft
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zipLeft<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O>;
+export declare function zipLeft<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, O>;
 /**
  * @tsplus pipeable fncts.io.Schedule zipRight
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zipRight<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O1>;
+export declare function zipRight<S1, R1, I1, O1>(that: Schedule.WithState<S1, R1, I1, O1>, __tsplusTrace?: string): <S, R, I, O>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, O1>;
 /**
  * @tsplus pipeable fncts.io.Schedule zipWith
  * @tsplus location "@fncts/io/Schedule/api"
  */
-export declare function zipWith<O, S1, R1, I1, O2, O3>(that: Schedule.WithState<S1, R1, I1, O2>, f: (out1: O, out2: O2) => O3, __tsplusTrace?: string): <S, R, I>(self: import("./definition.js").Schedule.WithState<S, R, I, O>) => import("./definition.js").Schedule.WithState<readonly [S, S1], R1 | R, I & I1, O3>;
+export declare function zipWith<O, S1, R1, I1, O2, O3>(that: Schedule.WithState<S1, R1, I1, O2>, f: (out1: O, out2: O2) => O3, __tsplusTrace?: string): <S, R, I>(self: Schedule.WithState<S, R, I, O>) => Schedule.WithState<readonly [S, S1], R | R1, I & I1, O3>;

package/Schedule.d.ts

@@ -1,4 +1,4 @@
-export * from "./Schedule/api.js";
-export * from "./Schedule/Decision.js";
 export * from "./Schedule/definition.js";
+export * from "./Schedule/api.js";
 export * from "./Schedule/Driver.js";
+export * from "./Schedule/Decision.js";

package/Scope/ReleaseMap.d.ts

@@ -1,3 +1,3 @@
-export * from "./ReleaseMap/api.js";
-export * from "./ReleaseMap/constructors.js";
 export * from "./ReleaseMap/definition.js";
+export * from "./ReleaseMap/constructors.js";
+export * from "./ReleaseMap/api.js";

package/Scope/api.d.ts

@@ -37,12 +37,17 @@ export declare const global: Scope.Closeable;
  * @tsplus location "@fncts/io/Scope/api"
  */
 export declare const make: UIO<Scope.Closeable>;
+/**
+ * @tsplus getter fncts.io.Scope fork
+ * @tsplus location "@fncts/io/Scope/api"
+ */
+export declare function fork(scope: Scope): UIO<Scope.Closeable>;
 /**
  * @tsplus static fncts.io.ScopeOps makeWith
  * @tsplus static fncts.io.Scope.CloseableOps makeWith
  * @tsplus location "@fncts/io/Scope/api"
  */
-export declare function makeWith(executionStrategy: Lazy<ExecutionStrategy>, __tsplusTrace?: string): UIO<Scope.Closeable>;
+export declare function makeWith(executionStrategy0: Lazy<ExecutionStrategy>, __tsplusTrace?: string): UIO<Scope.Closeable>;
 /**
  * @tsplus static fncts.io.ScopeOps unsafeMake
  * @tsplus location "@fncts/io/Scope/api"

package/Scope/definition.d.ts

@@ -1,6 +1,7 @@
 import { Finalizer } from "@fncts/io/Scope/Finalizer";
 import { UIO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { ExecutionStrategy } from "@fncts/base/data/ExecutionStrategy";
 import { Exit } from "@fncts/base/data/Exit/definition";
 export declare const ScopeTypeId: unique symbol;
 export type ScopeTypeId = typeof ScopeTypeId;
@@ -11,7 +12,8 @@ export type ScopeTypeId = typeof ScopeTypeId;
 export declare abstract class Scope {
     readonly [ScopeTypeId]: ScopeTypeId;
     abstract addFinalizerExit(finalizer: Finalizer): UIO<void>;
-    abstract fork: UIO<Scope.Closeable>;
+    abstract forkWith(executionStrategy: Lazy<ExecutionStrategy>): UIO<Scope.Closeable>;
+    executionStrategy: ExecutionStrategy;
 }
 /**
  * @tsplus type fncts.io.Scope.Closeable
@@ -28,5 +30,5 @@ export declare namespace Scope {
  * @tsplus static fncts.io.ScopeOps Tag
  * @tsplus location "@fncts/io/Scope/definition"
  */
-export declare const ScopeTag: import("@fncts/base/data/Tag").Tag<Scope>;
+export declare const ScopeTag: import("@fncts/base/data/Tag").Tag<Scope, Scope>;
 export {};

package/Scope.d.ts

@@ -1,2 +1,2 @@
-export * from "./Scope/api.js";
 export * from "./Scope/definition.js";
+export * from "./Scope/api.js";

package/ScopedRef.d.ts

@@ -1,2 +1,2 @@
-export * from "./ScopedRef/api.js";
 export * from "./ScopedRef/definition.js";
+export * from "./ScopedRef/api.js";

package/Semaphore.d.ts

@@ -14,7 +14,7 @@ export declare class Semaphore {
     runNext(): void;
     take(n: number): import("./IO").IO<never, never, number>;
     release(n: number): import("./IO").IO<never, never, void>;
-    withPermits(permits: number): <R, E, A>(io: import("./IO").IO<R, E, A>) => import("./IO").IO<R, E, A>;
+    withPermits(permits: number): <R, E, A>(io: IO<R, E, A>) => IO<R, E, A>;
     withPermit<R, E, A>(io: IO<R, E, A>): IO<R, E, A>;
 }
 /**