effect 2.0.0-next.44 → 2.0.0-next.46

package/dist/{schedule-1d92198c.cjs.prod.js → schedule-8cdf6bf1.cjs.prod.js}

@@ -7,15 +7,15 @@ var Duration_dist_effectDuration = require('../Duration/dist/effect-Duration.cjs
 var Either_dist_effectEither = require('../Either/dist/effect-Either.cjs.prod.js');
 var Equal_dist_effectEqual = require('../Equal/dist/effect-Equal.cjs.prod.js');
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.prod.js');
-var core = require('./core-0b0539de.cjs.prod.js');
-var Ref_dist_effectRef = require('./Ref-a3a4e50d.cjs.prod.js');
+var core = require('./core-07202cc0.cjs.prod.js');
+var Ref_dist_effectRef = require('./Ref-4014b526.cjs.prod.js');
 var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.prod.js');
 var Pipeable_dist_effectPipeable = require('../Pipeable/dist/effect-Pipeable.cjs.prod.js');
 var Random_dist_effectRandom = require('../Random/dist/effect-Random.cjs.prod.js');
 var ScheduleDecision_dist_effectScheduleDecision = require('../ScheduleDecision/dist/effect-ScheduleDecision.cjs.prod.js');
 var ScheduleInterval_dist_effectScheduleInterval = require('../ScheduleInterval/dist/effect-ScheduleInterval.cjs.prod.js');
 var ScheduleIntervals_dist_effectScheduleIntervals = require('../ScheduleIntervals/dist/effect-ScheduleIntervals.cjs.prod.js');
-var coreEffect = require('./core-effect-c65770cd.cjs.prod.js');
+var coreEffect = require('./core-effect-9201ea63.cjs.prod.js');
 
 /** @internal */
 const ScheduleSymbolKey = "effect/Schedule";
@@ -61,10 +61,10 @@ class ScheduleDriverImpl {
     this.ref = ref;
   }
   state() {
-    return core.map(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]);
+    return core.map$1(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]);
   }
   last() {
-    return core.flatMap(Ref_dist_effectRef.get$1(this.ref), ([element, _]) => {
+    return core.flatMap$1(Ref_dist_effectRef.get$1(this.ref), ([element, _]) => {
       switch (element._tag) {
         case "None":
           {
@@ -81,7 +81,7 @@ class ScheduleDriverImpl {
     return Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.none(), this.schedule.initial]);
   }
   next(input) {
-    return Function_dist_effectFunction.pipe(core.map(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]), core.flatMap(state => Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, core.flatMap(now => Function_dist_effectFunction.pipe(core.suspend(() => this.schedule.step(now, input, state)), core.flatMap(([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(core.fail(Option_dist_effectOption.none()))) : Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(coreEffect.sleep(Duration_dist_effectDuration.millis(ScheduleIntervals_dist_effectScheduleIntervals.start(decision.intervals) - now))), core.as(out))))))));
+    return Function_dist_effectFunction.pipe(core.map$1(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]), core.flatMap$1(state => Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, core.flatMap$1(now => Function_dist_effectFunction.pipe(core.suspend(() => this.schedule.step(now, input, state)), core.flatMap$1(([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(core.fail$1(Option_dist_effectOption.none()))) : Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(coreEffect.sleep(Duration_dist_effectDuration.millis(ScheduleIntervals_dist_effectScheduleIntervals.start(decision.intervals) - now))), core.as$1(out))))))));
   }
 }
 
@@ -92,18 +92,18 @@ const makeWithState = (initial, step) => new ScheduleImpl(initial, step);
 const addDelay = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => addDelayEffect(self, out => core.sync(() => f(out))));
 
 /** @internal */
-const addDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.map(f(out), delay => Duration_dist_effectDuration.sum(duration, Duration_dist_effectDuration.decode(delay)))));
+const addDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.map$1(f(out), delay => Duration_dist_effectDuration.sum(duration, Duration_dist_effectDuration.decode(delay)))));
 
 /** @internal */
 const andThen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => map(andThenEither(self, that), Either_dist_effectEither.merge));
 
 /** @internal */
-const andThenEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial, true], (now, input, state) => state[2] ? core.flatMap(self.step(now, input, state[0]), ([lState, out, decision]) => {
+const andThenEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial, true], (now, input, state) => state[2] ? core.flatMap$1(self.step(now, input, state[0]), ([lState, out, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-    return core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[lState, rState, false], Either_dist_effectEither.right(out), decision]);
+    return core.map$1(that.step(now, input, state[1]), ([rState, out, decision]) => [[lState, rState, false], Either_dist_effectEither.right(out), decision]);
   }
   return core.succeed([[lState, state[1], true], Either_dist_effectEither.left(out), decision]);
-}) : core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[state[0], rState, false], Either_dist_effectEither.right(out), decision])));
+}) : core.map$1(that.step(now, input, state[1]), ([rState, out, decision]) => [[state[0], rState, false], Either_dist_effectEither.right(out), decision])));
 
 /** @internal */
 const as = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, out) => map(self, () => out));
@@ -124,11 +124,11 @@ const bothInOut = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that)
 const check = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => checkEffect(self, (input, out) => core.sync(() => test(input, out))));
 
 /** @internal */
-const checkEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+const checkEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
     return core.succeed([state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
   }
-  return core.map(test(input, out), cont => cont ? [state, out, decision] : [state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
+  return core.map$1(test(input, out), cont => cont ? [state, out, decision] : [state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
 })));
 /** @internal */
 const collectAllInputs = () => collectAllOutputs(identity());
@@ -149,7 +149,7 @@ const collectWhile = f => collectAllOutputs(recurWhile(f));
 const collectWhileEffect = f => collectAllOutputs(recurWhileEffect(f));
 
 /** @internal */
-const compose = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, input, state) => core.flatMap(self.step(now, input, state[0]), ([lState, out, lDecision]) => core.map(that.step(now, out, state[1]), ([rState, out2, rDecision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(lDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : ScheduleDecision_dist_effectScheduleDecision.isDone(rDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision["continue"](Function_dist_effectFunction.pipe(lDecision.intervals, ScheduleIntervals_dist_effectScheduleIntervals.max(rDecision.intervals)))]))));
+const compose = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, input, state) => core.flatMap$1(self.step(now, input, state[0]), ([lState, out, lDecision]) => core.map$1(that.step(now, out, state[1]), ([rState, out2, rDecision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(lDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : ScheduleDecision_dist_effectScheduleDecision.isDone(rDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision["continue"](Function_dist_effectFunction.pipe(lDecision.intervals, ScheduleIntervals_dist_effectScheduleIntervals.max(rDecision.intervals)))]))));
 
 /** @internal */
 const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapInputEffect(self, input2 => core.sync(() => f(input2))));
@@ -158,7 +158,7 @@ const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) =>
 const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.mapInputContext(self.step(now, input, state), f)));
 
 /** @internal */
-const mapInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input2, state) => core.flatMap(f(input2), input => self.step(now, input, state))));
+const mapInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input2, state) => core.flatMap$1(f(input2), input => self.step(now, input, state))));
 
 /** @internal */
 const dayOfMonth = day => {
@@ -202,7 +202,7 @@ const delayedEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f
 const delayedSchedule = schedule => addDelay(schedule, x => x);
 
 /** @internal */
-const delays = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.flatMap(([state, _, decision]) => {
+const delays = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.flatMap$1(([state, _, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
     return core.succeed([state, Duration_dist_effectDuration.zero, decision]);
   }
@@ -222,7 +222,7 @@ const mapBothEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
 }) => mapEffect(mapInputEffect(self, onInput), onOutput));
 
 /** @internal */
-const driver = self => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make$1([Option_dist_effectOption.none(), self.initial]), core.map(ref => new ScheduleDriverImpl(self, ref)));
+const driver = self => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make$1([Option_dist_effectOption.none(), self.initial]), core.map$1(ref => new ScheduleDriverImpl(self, ref)));
 
 /** @internal */
 const duration = durationInput => {
@@ -238,7 +238,7 @@ const either = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) =>
 const eitherWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => unionWith(self, that, f));
 
 /** @internal */
-const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.as(finalizer, [state, out, decision]) : core.succeed([state, out, decision]))));
+const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.as$1(finalizer, [state, out, decision]) : core.succeed([state, out, decision]))));
 
 /** @internal */
 const exponential = (baseInput, factor = 2.0) => {
@@ -316,7 +316,7 @@ const identity = () => makeWithState(void 0, (now, input, state) => core.succeed
 const intersect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => intersectWith(self, that, ScheduleIntervals_dist_effectScheduleIntervals.intersect));
 
 /** @internal */
-const intersectWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => Function_dist_effectFunction.pipe(core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), core.flatMap(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
+const intersectWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => Function_dist_effectFunction.pipe(core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), core.flatMap$1(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isContinue(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isContinue(rDecision)) {
     return intersectWithLoop(self, that, input, lState, out, lDecision.intervals, rState, out2, rDecision.intervals, f);
   }
@@ -330,14 +330,14 @@ const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, ou
     return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision["continue"](combined)]);
   }
   if (Function_dist_effectFunction.pipe(lInterval, ScheduleIntervals_dist_effectScheduleIntervals.lessThan(rInterval))) {
-    return core.flatMap(self.step(ScheduleIntervals_dist_effectScheduleIntervals.end(lInterval), input, lState), ([lState, out, decision]) => {
+    return core.flatMap$1(self.step(ScheduleIntervals_dist_effectScheduleIntervals.end(lInterval), input, lState), ([lState, out, decision]) => {
       if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
         return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done]);
       }
       return intersectWithLoop(self, that, input, lState, out, decision.intervals, rState, out2, rInterval, f);
     });
   }
-  return core.flatMap(that.step(ScheduleIntervals_dist_effectScheduleIntervals.end(rInterval), input, rState), ([rState, out2, decision]) => {
+  return core.flatMap$1(that.step(ScheduleIntervals_dist_effectScheduleIntervals.end(rInterval), input, rState), ([rState, out2, decision]) => {
     if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
       return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done]);
     }
@@ -360,7 +360,7 @@ const jitteredWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, op
     min: 0.8,
     max: 1.2
   }, options);
-  return delayedEffect(self, duration => core.map(Random_dist_effectRandom.next, random => {
+  return delayedEffect(self, duration => core.map$1(Random_dist_effectRandom.next, random => {
     const d = Duration_dist_effectDuration.toMillis(duration);
     const jittered = d * min * (1 - random) + d * max * random;
     return Duration_dist_effectDuration.millis(jittered);
@@ -377,7 +377,7 @@ const linear = baseInput => {
 const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapEffect(self, out => core.sync(() => f(out))));
 
 /** @internal */
-const mapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.map(f(out), out2 => [state, out2, decision]))));
+const mapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => core.map$1(f(out), out2 => [state, out2, decision]))));
 
 /** @internal */
 const minuteOfHour = minute => makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
@@ -397,13 +397,13 @@ const minuteOfHour = minute => makeWithState([Number.MIN_SAFE_INTEGER, 0], (now,
 const modifyDelay = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.sync(() => f(out, duration))));
 
 /** @internal */
-const modifyDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+const modifyDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
     return core.succeed([state, out, decision]);
   }
   const intervals = decision.intervals;
   const delay = ScheduleInterval_dist_effectScheduleInterval.size(ScheduleInterval_dist_effectScheduleInterval.make(now, ScheduleIntervals_dist_effectScheduleIntervals.start(intervals)));
-  return core.map(f(out, delay), durationInput => {
+  return core.map$1(f(out, delay), durationInput => {
     const duration = Duration_dist_effectDuration.decode(durationInput);
     const oldStart = ScheduleIntervals_dist_effectScheduleIntervals.start(intervals);
     const newStart = now + Duration_dist_effectDuration.toMillis(duration);
@@ -415,10 +415,10 @@ const modifyDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (sel
 })));
 
 /** @internal */
-const onDecision = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.as(f(out, decision), [state, out, decision]))));
+const onDecision = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => core.as$1(f(out, decision), [state, out, decision]))));
 
 /** @internal */
-const passthrough = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.map(([state, _, decision]) => [state, input, decision])));
+const passthrough = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.map$1(([state, _, decision]) => [state, input, decision])));
 
 /** @internal */
 const provideContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => makeWithState(self.initial, (now, input, state) => core.provideContext(self.step(now, input, state), context)));
@@ -456,7 +456,7 @@ const recurs = n => whileOutput(forever, out => out < n);
 const reduce = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => reduceEffect(self, zero, (z, out) => core.sync(() => f(z, out))));
 
 /** @internal */
-const reduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => makeWithState([self.initial, zero], (now, input, [s, z]) => core.flatMap(self.step(now, input, s), ([s, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.succeed([[s, z], z, decision]) : core.map(f(z, out), z2 => [[s, z2], z, decision]))));
+const reduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => makeWithState([self.initial, zero], (now, input, [s, z]) => core.flatMap$1(self.step(now, input, s), ([s, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.succeed([[s, z], z, decision]) : core.map$1(f(z, out), z2 => [[s, z2], z, decision]))));
 
 /** @internal */
 const repetitions = self => reduce(self, 0, (n, _) => n + 1);
@@ -468,10 +468,10 @@ const resetAfter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, dura
 });
 
 /** @internal */
-const resetWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => f(out) ? self.step(now, input, self.initial) : core.succeed([state, out, decision]))));
+const resetWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => f(out) ? self.step(now, input, self.initial) : core.succeed([state, out, decision]))));
 
 /** @internal */
-const run = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, now, input) => Function_dist_effectFunction.pipe(runLoop(self, now, Chunk_dist_effectChunk.fromIterable(input), self.initial, Chunk_dist_effectChunk.empty()), core.map(list => Chunk_dist_effectChunk.reverse(list))));
+const run = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, now, input) => Function_dist_effectFunction.pipe(runLoop(self, now, Chunk_dist_effectChunk.fromIterable(input), self.initial, Chunk_dist_effectChunk.empty()), core.map$1(list => Chunk_dist_effectChunk.reverse(list))));
 
 /** @internal */
 const runLoop = (self, now, inputs, state, acc) => {
@@ -480,7 +480,7 @@ const runLoop = (self, now, inputs, state, acc) => {
   }
   const input = Chunk_dist_effectChunk.headNonEmpty(inputs);
   const nextInputs = Chunk_dist_effectChunk.tailNonEmpty(inputs);
-  return core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+  return core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => {
     if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
       return core.sync(() => Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.prepend(out)));
     }
@@ -739,10 +739,10 @@ const findNextMonth = (now, day, months) => {
 // circular with Effect
 
 /** @internal */
-const repeat_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail(e)));
+const repeat_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail$1(e)));
 
 /** @internal */
-const repeatOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, orElse) => core.flatMap(driver(schedule), driver => core.matchEffect(self, {
+const repeatOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, orElse) => core.flatMap$1(driver(schedule), driver => core.matchEffect(self, {
   onFailure: error => orElse(error, Option_dist_effectOption.none()),
   onSuccess: value => repeatOrElseEffectLoop(self, driver, orElse, value)
 })));
@@ -762,7 +762,7 @@ const repeatOrElseEffectLoop = (self, driver, orElse, value) => {
 const repeatUntil_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatUntilEffect_Effect(self, a => core.sync(() => f(a))));
 
 /** @internal */
-const repeatUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.flatMap(self, a => core.flatMap(f(a), result => result ? core.succeed(a) : core.flatMap(core.yieldNow(), () => repeatUntilEffect_Effect(self, f)))));
+const repeatUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.flatMap$1(self, a => core.flatMap$1(f(a), result => result ? core.succeed(a) : core.flatMap$1(core.yieldNow(), () => repeatUntilEffect_Effect(self, f)))));
 
 /** @internal */
 const repeatWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatWhileEffect_Effect(self, a => core.sync(() => f(a))));
@@ -771,23 +771,23 @@ const repeatWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (se
 const repeatWhileEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatUntilEffect_Effect(self, a => coreEffect.negate(f(a))));
 
 /** @internal */
-const retry_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail(e)));
+const retry_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail$1(e)));
 
 /** @internal */
 const retryN_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => retryN_EffectLoop(self, n));
 
 /** @internal */
 const retryN_EffectLoop = (self, n) => {
-  return core.catchAll(self, e => n < 0 ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryN_EffectLoop(self, n - 1)));
+  return core.catchAll(self, e => n < 0 ? core.fail$1(e) : core.flatMap$1(core.yieldNow(), () => retryN_EffectLoop(self, n - 1)));
 };
 
 /** @internal */
-const retryOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, policy, orElse) => core.flatMap(driver(policy), driver => retryOrElse_EffectLoop(self, driver, orElse)));
+const retryOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, policy, orElse) => core.flatMap$1(driver(policy), driver => retryOrElse_EffectLoop(self, driver, orElse)));
 
 /** @internal */
 const retryOrElse_EffectLoop = (self, driver, orElse) => {
   return core.catchAll(self, e => core.matchEffect(driver.next(e), {
-    onFailure: () => Function_dist_effectFunction.pipe(driver.last(), core.orDie, core.flatMap(out => orElse(e, out))),
+    onFailure: () => Function_dist_effectFunction.pipe(driver.last(), core.orDie, core.flatMap$1(out => orElse(e, out))),
     onSuccess: () => retryOrElse_EffectLoop(self, driver, orElse)
   }));
 };
@@ -796,7 +796,7 @@ const retryOrElse_EffectLoop = (self, driver, orElse) => {
 const retryUntil_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => retryUntilEffect_Effect(self, e => core.sync(() => f(e))));
 
 /** @internal */
-const retryUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.catchAll(self, e => core.flatMap(f(e), b => b ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryUntilEffect_Effect(self, f)))));
+const retryUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.catchAll(self, e => core.flatMap$1(f(e), b => b ? core.fail$1(e) : core.flatMap$1(core.yieldNow(), () => retryUntilEffect_Effect(self, f)))));
 
 /** @internal */
 const retryWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => retryWhileEffect_Effect(self, e => core.sync(() => f(e))));
@@ -808,12 +808,12 @@ const retryWhileEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2
 const schedule_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => scheduleFrom_Effect(self, void 0, schedule));
 
 /** @internal */
-const scheduleFrom_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, initial, schedule) => core.flatMap(driver(schedule), driver => scheduleFrom_EffectLoop(self, initial, driver)));
+const scheduleFrom_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, initial, schedule) => core.flatMap$1(driver(schedule), driver => scheduleFrom_EffectLoop(self, initial, driver)));
 
 /** @internal */
 const scheduleFrom_EffectLoop = (self, initial, driver) => core.matchEffect(driver.next(initial), {
   onFailure: () => core.orDie(driver.last()),
-  onSuccess: () => core.flatMap(self, a => scheduleFrom_EffectLoop(self, a, driver))
+  onSuccess: () => core.flatMap$1(self, a => scheduleFrom_EffectLoop(self, a, driver))
 });
 
 /** @internal */

package/dist/{schedule-e0f55cab.cjs.dev.js → schedule-e7a9f93f.cjs.dev.js}

@@ -7,15 +7,15 @@ var Duration_dist_effectDuration = require('../Duration/dist/effect-Duration.cjs
 var Either_dist_effectEither = require('../Either/dist/effect-Either.cjs.dev.js');
 var Equal_dist_effectEqual = require('../Equal/dist/effect-Equal.cjs.dev.js');
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
-var core = require('./core-b4d7b4f5.cjs.dev.js');
-var Ref_dist_effectRef = require('./Ref-74b592a4.cjs.dev.js');
+var core = require('./core-b7401357.cjs.dev.js');
+var Ref_dist_effectRef = require('./Ref-acdee7ef.cjs.dev.js');
 var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.dev.js');
 var Pipeable_dist_effectPipeable = require('../Pipeable/dist/effect-Pipeable.cjs.dev.js');
 var Random_dist_effectRandom = require('../Random/dist/effect-Random.cjs.dev.js');
 var ScheduleDecision_dist_effectScheduleDecision = require('../ScheduleDecision/dist/effect-ScheduleDecision.cjs.dev.js');
 var ScheduleInterval_dist_effectScheduleInterval = require('../ScheduleInterval/dist/effect-ScheduleInterval.cjs.dev.js');
 var ScheduleIntervals_dist_effectScheduleIntervals = require('../ScheduleIntervals/dist/effect-ScheduleIntervals.cjs.dev.js');
-var coreEffect = require('./core-effect-892f3686.cjs.dev.js');
+var coreEffect = require('./core-effect-1c564d42.cjs.dev.js');
 
 /** @internal */
 const ScheduleSymbolKey = "effect/Schedule";
@@ -61,10 +61,10 @@ class ScheduleDriverImpl {
     this.ref = ref;
   }
   state() {
-    return core.map(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]);
+    return core.map$1(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]);
   }
   last() {
-    return core.flatMap(Ref_dist_effectRef.get$1(this.ref), ([element, _]) => {
+    return core.flatMap$1(Ref_dist_effectRef.get$1(this.ref), ([element, _]) => {
       switch (element._tag) {
         case "None":
           {
@@ -81,7 +81,7 @@ class ScheduleDriverImpl {
     return Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.none(), this.schedule.initial]);
   }
   next(input) {
-    return Function_dist_effectFunction.pipe(core.map(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]), core.flatMap(state => Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, core.flatMap(now => Function_dist_effectFunction.pipe(core.suspend(() => this.schedule.step(now, input, state)), core.flatMap(([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(core.fail(Option_dist_effectOption.none()))) : Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(coreEffect.sleep(Duration_dist_effectDuration.millis(ScheduleIntervals_dist_effectScheduleIntervals.start(decision.intervals) - now))), core.as(out))))))));
+    return Function_dist_effectFunction.pipe(core.map$1(Ref_dist_effectRef.get$1(this.ref), tuple => tuple[1]), core.flatMap$1(state => Function_dist_effectFunction.pipe(Clock_dist_effectClock.currentTimeMillis, core.flatMap$1(now => Function_dist_effectFunction.pipe(core.suspend(() => this.schedule.step(now, input, state)), core.flatMap$1(([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(core.fail$1(Option_dist_effectOption.none()))) : Function_dist_effectFunction.pipe(Ref_dist_effectRef.set$1(this.ref, [Option_dist_effectOption.some(out), state]), core.zipRight(coreEffect.sleep(Duration_dist_effectDuration.millis(ScheduleIntervals_dist_effectScheduleIntervals.start(decision.intervals) - now))), core.as$1(out))))))));
   }
 }
 
@@ -92,18 +92,18 @@ const makeWithState = (initial, step) => new ScheduleImpl(initial, step);
 const addDelay = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => addDelayEffect(self, out => core.sync(() => f(out))));
 
 /** @internal */
-const addDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.map(f(out), delay => Duration_dist_effectDuration.sum(duration, Duration_dist_effectDuration.decode(delay)))));
+const addDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.map$1(f(out), delay => Duration_dist_effectDuration.sum(duration, Duration_dist_effectDuration.decode(delay)))));
 
 /** @internal */
 const andThen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => map(andThenEither(self, that), Either_dist_effectEither.merge));
 
 /** @internal */
-const andThenEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial, true], (now, input, state) => state[2] ? core.flatMap(self.step(now, input, state[0]), ([lState, out, decision]) => {
+const andThenEither = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial, true], (now, input, state) => state[2] ? core.flatMap$1(self.step(now, input, state[0]), ([lState, out, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
-    return core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[lState, rState, false], Either_dist_effectEither.right(out), decision]);
+    return core.map$1(that.step(now, input, state[1]), ([rState, out, decision]) => [[lState, rState, false], Either_dist_effectEither.right(out), decision]);
   }
   return core.succeed([[lState, state[1], true], Either_dist_effectEither.left(out), decision]);
-}) : core.map(that.step(now, input, state[1]), ([rState, out, decision]) => [[state[0], rState, false], Either_dist_effectEither.right(out), decision])));
+}) : core.map$1(that.step(now, input, state[1]), ([rState, out, decision]) => [[state[0], rState, false], Either_dist_effectEither.right(out), decision])));
 
 /** @internal */
 const as = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, out) => map(self, () => out));
@@ -124,11 +124,11 @@ const bothInOut = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that)
 const check = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => checkEffect(self, (input, out) => core.sync(() => test(input, out))));
 
 /** @internal */
-const checkEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+const checkEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
     return core.succeed([state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
   }
-  return core.map(test(input, out), cont => cont ? [state, out, decision] : [state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
+  return core.map$1(test(input, out), cont => cont ? [state, out, decision] : [state, out, ScheduleDecision_dist_effectScheduleDecision.done]);
 })));
 /** @internal */
 const collectAllInputs = () => collectAllOutputs(identity());
@@ -149,7 +149,7 @@ const collectWhile = f => collectAllOutputs(recurWhile(f));
 const collectWhileEffect = f => collectAllOutputs(recurWhileEffect(f));
 
 /** @internal */
-const compose = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, input, state) => core.flatMap(self.step(now, input, state[0]), ([lState, out, lDecision]) => core.map(that.step(now, out, state[1]), ([rState, out2, rDecision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(lDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : ScheduleDecision_dist_effectScheduleDecision.isDone(rDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision["continue"](Function_dist_effectFunction.pipe(lDecision.intervals, ScheduleIntervals_dist_effectScheduleIntervals.max(rDecision.intervals)))]))));
+const compose = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, input, state) => core.flatMap$1(self.step(now, input, state[0]), ([lState, out, lDecision]) => core.map$1(that.step(now, out, state[1]), ([rState, out2, rDecision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(lDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : ScheduleDecision_dist_effectScheduleDecision.isDone(rDecision) ? [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision.done] : [[lState, rState], out2, ScheduleDecision_dist_effectScheduleDecision["continue"](Function_dist_effectFunction.pipe(lDecision.intervals, ScheduleIntervals_dist_effectScheduleIntervals.max(rDecision.intervals)))]))));
 
 /** @internal */
 const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapInputEffect(self, input2 => core.sync(() => f(input2))));
@@ -158,7 +158,7 @@ const mapInput = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) =>
 const mapInputContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.mapInputContext(self.step(now, input, state), f)));
 
 /** @internal */
-const mapInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input2, state) => core.flatMap(f(input2), input => self.step(now, input, state))));
+const mapInputEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input2, state) => core.flatMap$1(f(input2), input => self.step(now, input, state))));
 
 /** @internal */
 const dayOfMonth = day => {
@@ -202,7 +202,7 @@ const delayedEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f
 const delayedSchedule = schedule => addDelay(schedule, x => x);
 
 /** @internal */
-const delays = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.flatMap(([state, _, decision]) => {
+const delays = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.flatMap$1(([state, _, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
     return core.succeed([state, Duration_dist_effectDuration.zero, decision]);
   }
@@ -222,7 +222,7 @@ const mapBothEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, {
 }) => mapEffect(mapInputEffect(self, onInput), onOutput));
 
 /** @internal */
-const driver = self => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make$1([Option_dist_effectOption.none(), self.initial]), core.map(ref => new ScheduleDriverImpl(self, ref)));
+const driver = self => Function_dist_effectFunction.pipe(Ref_dist_effectRef.make$1([Option_dist_effectOption.none(), self.initial]), core.map$1(ref => new ScheduleDriverImpl(self, ref)));
 
 /** @internal */
 const duration = durationInput => {
@@ -238,7 +238,7 @@ const either = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) =>
 const eitherWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => unionWith(self, that, f));
 
 /** @internal */
-const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.as(finalizer, [state, out, decision]) : core.succeed([state, out, decision]))));
+const ensuring = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, finalizer) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.as$1(finalizer, [state, out, decision]) : core.succeed([state, out, decision]))));
 
 /** @internal */
 const exponential = (baseInput, factor = 2.0) => {
@@ -316,7 +316,7 @@ const identity = () => makeWithState(void 0, (now, input, state) => core.succeed
 const intersect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, that) => intersectWith(self, that, ScheduleIntervals_dist_effectScheduleIntervals.intersect));
 
 /** @internal */
-const intersectWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => Function_dist_effectFunction.pipe(core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), core.flatMap(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
+const intersectWith = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => Function_dist_effectFunction.pipe(core.zipWith(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), core.flatMap$1(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isContinue(lDecision) && ScheduleDecision_dist_effectScheduleDecision.isContinue(rDecision)) {
     return intersectWithLoop(self, that, input, lState, out, lDecision.intervals, rState, out2, rDecision.intervals, f);
   }
@@ -330,14 +330,14 @@ const intersectWithLoop = (self, that, input, lState, out, lInterval, rState, ou
     return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision["continue"](combined)]);
   }
   if (Function_dist_effectFunction.pipe(lInterval, ScheduleIntervals_dist_effectScheduleIntervals.lessThan(rInterval))) {
-    return core.flatMap(self.step(ScheduleIntervals_dist_effectScheduleIntervals.end(lInterval), input, lState), ([lState, out, decision]) => {
+    return core.flatMap$1(self.step(ScheduleIntervals_dist_effectScheduleIntervals.end(lInterval), input, lState), ([lState, out, decision]) => {
       if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
         return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done]);
       }
       return intersectWithLoop(self, that, input, lState, out, decision.intervals, rState, out2, rInterval, f);
     });
   }
-  return core.flatMap(that.step(ScheduleIntervals_dist_effectScheduleIntervals.end(rInterval), input, rState), ([rState, out2, decision]) => {
+  return core.flatMap$1(that.step(ScheduleIntervals_dist_effectScheduleIntervals.end(rInterval), input, rState), ([rState, out2, decision]) => {
     if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
       return core.succeed([[lState, rState], [out, out2], ScheduleDecision_dist_effectScheduleDecision.done]);
     }
@@ -360,7 +360,7 @@ const jitteredWith = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, op
     min: 0.8,
     max: 1.2
   }, options);
-  return delayedEffect(self, duration => core.map(Random_dist_effectRandom.next, random => {
+  return delayedEffect(self, duration => core.map$1(Random_dist_effectRandom.next, random => {
     const d = Duration_dist_effectDuration.toMillis(duration);
     const jittered = d * min * (1 - random) + d * max * random;
     return Duration_dist_effectDuration.millis(jittered);
@@ -377,7 +377,7 @@ const linear = baseInput => {
 const map = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => mapEffect(self, out => core.sync(() => f(out))));
 
 /** @internal */
-const mapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.map(f(out), out2 => [state, out2, decision]))));
+const mapEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => core.map$1(f(out), out2 => [state, out2, decision]))));
 
 /** @internal */
 const minuteOfHour = minute => makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
@@ -397,13 +397,13 @@ const minuteOfHour = minute => makeWithState([Number.MIN_SAFE_INTEGER, 0], (now,
 const modifyDelay = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => modifyDelayEffect(self, (out, duration) => core.sync(() => f(out, duration))));
 
 /** @internal */
-const modifyDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+const modifyDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => {
   if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
     return core.succeed([state, out, decision]);
   }
   const intervals = decision.intervals;
   const delay = ScheduleInterval_dist_effectScheduleInterval.size(ScheduleInterval_dist_effectScheduleInterval.make(now, ScheduleIntervals_dist_effectScheduleIntervals.start(intervals)));
-  return core.map(f(out, delay), durationInput => {
+  return core.map$1(f(out, delay), durationInput => {
     const duration = Duration_dist_effectDuration.decode(durationInput);
     const oldStart = ScheduleIntervals_dist_effectScheduleIntervals.start(intervals);
     const newStart = now + Duration_dist_effectDuration.toMillis(duration);
@@ -415,10 +415,10 @@ const modifyDelayEffect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (sel
 })));
 
 /** @internal */
-const onDecision = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => core.as(f(out, decision), [state, out, decision]))));
+const onDecision = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => core.as$1(f(out, decision), [state, out, decision]))));
 
 /** @internal */
-const passthrough = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.map(([state, _, decision]) => [state, input, decision])));
+const passthrough = self => makeWithState(self.initial, (now, input, state) => Function_dist_effectFunction.pipe(self.step(now, input, state), core.map$1(([state, _, decision]) => [state, input, decision])));
 
 /** @internal */
 const provideContext = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, context) => makeWithState(self.initial, (now, input, state) => core.provideContext(self.step(now, input, state), context)));
@@ -456,7 +456,7 @@ const recurs = n => whileOutput(forever, out => out < n);
 const reduce = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => reduceEffect(self, zero, (z, out) => core.sync(() => f(z, out))));
 
 /** @internal */
-const reduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => makeWithState([self.initial, zero], (now, input, [s, z]) => core.flatMap(self.step(now, input, s), ([s, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.succeed([[s, z], z, decision]) : core.map(f(z, out), z2 => [[s, z2], z, decision]))));
+const reduceEffect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, zero, f) => makeWithState([self.initial, zero], (now, input, [s, z]) => core.flatMap$1(self.step(now, input, s), ([s, out, decision]) => ScheduleDecision_dist_effectScheduleDecision.isDone(decision) ? core.succeed([[s, z], z, decision]) : core.map$1(f(z, out), z2 => [[s, z2], z, decision]))));
 
 /** @internal */
 const repetitions = self => reduce(self, 0, (n, _) => n + 1);
@@ -468,10 +468,10 @@ const resetAfter = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, dura
 });
 
 /** @internal */
-const resetWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap(self.step(now, input, state), ([state, out, decision]) => f(out) ? self.step(now, input, self.initial) : core.succeed([state, out, decision]))));
+const resetWhen = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => f(out) ? self.step(now, input, self.initial) : core.succeed([state, out, decision]))));
 
 /** @internal */
-const run = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, now, input) => Function_dist_effectFunction.pipe(runLoop(self, now, Chunk_dist_effectChunk.fromIterable(input), self.initial, Chunk_dist_effectChunk.empty()), core.map(list => Chunk_dist_effectChunk.reverse(list))));
+const run = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, now, input) => Function_dist_effectFunction.pipe(runLoop(self, now, Chunk_dist_effectChunk.fromIterable(input), self.initial, Chunk_dist_effectChunk.empty()), core.map$1(list => Chunk_dist_effectChunk.reverse(list))));
 
 /** @internal */
 const runLoop = (self, now, inputs, state, acc) => {
@@ -480,7 +480,7 @@ const runLoop = (self, now, inputs, state, acc) => {
   }
   const input = Chunk_dist_effectChunk.headNonEmpty(inputs);
   const nextInputs = Chunk_dist_effectChunk.tailNonEmpty(inputs);
-  return core.flatMap(self.step(now, input, state), ([state, out, decision]) => {
+  return core.flatMap$1(self.step(now, input, state), ([state, out, decision]) => {
     if (ScheduleDecision_dist_effectScheduleDecision.isDone(decision)) {
       return core.sync(() => Function_dist_effectFunction.pipe(acc, Chunk_dist_effectChunk.prepend(out)));
     }
@@ -739,10 +739,10 @@ const findNextMonth = (now, day, months) => {
 // circular with Effect
 
 /** @internal */
-const repeat_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail(e)));
+const repeat_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => repeatOrElse_Effect(self, schedule, (e, _) => core.fail$1(e)));
 
 /** @internal */
-const repeatOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, orElse) => core.flatMap(driver(schedule), driver => core.matchEffect(self, {
+const repeatOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, schedule, orElse) => core.flatMap$1(driver(schedule), driver => core.matchEffect(self, {
   onFailure: error => orElse(error, Option_dist_effectOption.none()),
   onSuccess: value => repeatOrElseEffectLoop(self, driver, orElse, value)
 })));
@@ -762,7 +762,7 @@ const repeatOrElseEffectLoop = (self, driver, orElse, value) => {
 const repeatUntil_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatUntilEffect_Effect(self, a => core.sync(() => f(a))));
 
 /** @internal */
-const repeatUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.flatMap(self, a => core.flatMap(f(a), result => result ? core.succeed(a) : core.flatMap(core.yieldNow(), () => repeatUntilEffect_Effect(self, f)))));
+const repeatUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.flatMap$1(self, a => core.flatMap$1(f(a), result => result ? core.succeed(a) : core.flatMap$1(core.yieldNow(), () => repeatUntilEffect_Effect(self, f)))));
 
 /** @internal */
 const repeatWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatWhileEffect_Effect(self, a => core.sync(() => f(a))));
@@ -771,23 +771,23 @@ const repeatWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (se
 const repeatWhileEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => repeatUntilEffect_Effect(self, a => coreEffect.negate(f(a))));
 
 /** @internal */
-const retry_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail(e)));
+const retry_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => core.fail$1(e)));
 
 /** @internal */
 const retryN_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, n) => retryN_EffectLoop(self, n));
 
 /** @internal */
 const retryN_EffectLoop = (self, n) => {
-  return core.catchAll(self, e => n < 0 ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryN_EffectLoop(self, n - 1)));
+  return core.catchAll(self, e => n < 0 ? core.fail$1(e) : core.flatMap$1(core.yieldNow(), () => retryN_EffectLoop(self, n - 1)));
 };
 
 /** @internal */
-const retryOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, policy, orElse) => core.flatMap(driver(policy), driver => retryOrElse_EffectLoop(self, driver, orElse)));
+const retryOrElse_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, policy, orElse) => core.flatMap$1(driver(policy), driver => retryOrElse_EffectLoop(self, driver, orElse)));
 
 /** @internal */
 const retryOrElse_EffectLoop = (self, driver, orElse) => {
   return core.catchAll(self, e => core.matchEffect(driver.next(e), {
-    onFailure: () => Function_dist_effectFunction.pipe(driver.last(), core.orDie, core.flatMap(out => orElse(e, out))),
+    onFailure: () => Function_dist_effectFunction.pipe(driver.last(), core.orDie, core.flatMap$1(out => orElse(e, out))),
     onSuccess: () => retryOrElse_EffectLoop(self, driver, orElse)
   }));
 };
@@ -796,7 +796,7 @@ const retryOrElse_EffectLoop = (self, driver, orElse) => {
 const retryUntil_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => retryUntilEffect_Effect(self, e => core.sync(() => f(e))));
 
 /** @internal */
-const retryUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.catchAll(self, e => core.flatMap(f(e), b => b ? core.fail(e) : core.flatMap(core.yieldNow(), () => retryUntilEffect_Effect(self, f)))));
+const retryUntilEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => core.catchAll(self, e => core.flatMap$1(f(e), b => b ? core.fail$1(e) : core.flatMap$1(core.yieldNow(), () => retryUntilEffect_Effect(self, f)))));
 
 /** @internal */
 const retryWhile_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, f) => retryWhileEffect_Effect(self, e => core.sync(() => f(e))));
@@ -808,12 +808,12 @@ const retryWhileEffect_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2
 const schedule_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(2, (self, schedule) => scheduleFrom_Effect(self, void 0, schedule));
 
 /** @internal */
-const scheduleFrom_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, initial, schedule) => core.flatMap(driver(schedule), driver => scheduleFrom_EffectLoop(self, initial, driver)));
+const scheduleFrom_Effect = /*#__PURE__*/Function_dist_effectFunction.dual(3, (self, initial, schedule) => core.flatMap$1(driver(schedule), driver => scheduleFrom_EffectLoop(self, initial, driver)));
 
 /** @internal */
 const scheduleFrom_EffectLoop = (self, initial, driver) => core.matchEffect(driver.next(initial), {
   onFailure: () => core.orDie(driver.last()),
-  onSuccess: () => core.flatMap(self, a => scheduleFrom_EffectLoop(self, a, driver))
+  onSuccess: () => core.flatMap$1(self, a => scheduleFrom_EffectLoop(self, a, driver))
 });
 
 /** @internal */