@typed/fx 1.18.4 → 1.20.0

package/dist/cjs/internal/core.js

@@ -3,922 +3,1733 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.acquireUseRelease = void 0;
-exports.combine = combine;
-exports.continueWith = exports.concatMap = exports.compact = void 0;
-exports.drain = drain;
-exports.flatten = exports.flatMapWithStrategy = exports.flatMapErrorWithStrategy = exports.flatMapErrorConcurrently = exports.flatMapError = exports.flatMapConcurrently = exports.flatMapCauseWithStrategy = exports.flatMapCauseConcurrently = exports.flatMapCause = exports.flatMap = exports.filterMapErrorEffect = exports.filterMapError = exports.filterMapEffect = exports.filterMapCause = exports.filterMap = exports.filterError = exports.filterEffect = exports.filterCause = exports.filter = exports.failCause = exports.fail = exports.exhaustMatchCause = exports.exhaustMatch = exports.exhaustMapLatestError = exports.exhaustMapLatestCause = exports.exhaustMapLatest = exports.exhaustMapError = exports.exhaustMapCause = exports.exhaustMap = exports.exhaustLatestMatchCause = exports.exhaustLatestMatch = exports.exhaustLatest = exports.exhaust = exports.endWith = exports.empty = exports.during = exports.dropWhile = exports.dropUntil = exports.dropAfter = exports.drop = void 0;
-exports.from = from;
-exports.fromEffect = fromEffect;
-exports.fromEmitter = fromEmitter;
-exports.fromIterable = fromIterable;
-exports.fromSink = exports.fromScheduled = void 0;
-exports.fromStream = fromStream;
-exports.matchErrorWithStrategy = exports.matchErrorConcurrently = exports.matchCauseWithStrategy = exports.matchCauseConcurrently = exports.matchCause = exports.match = exports.mapErrorCause = exports.mapError = exports.mapEffect = exports.mapBoth = exports.map = exports.loopEffect = exports.loop = void 0;
+exports.acquireUseRelease = acquireUseRelease;
+exports.all = all;
+exports.annotateLogs = annotateLogs;
+exports.annotateSpans = annotateSpans;
+exports.append = append;
+exports.appendAll = appendAll;
+exports.concatMap = concatMap;
+exports.continueWith = continueWith;
+exports.debounce = debounce;
+exports.drop = exports.drain = exports.die = void 0;
+exports.dropAfter = dropAfter;
+exports.dropAfterEffect = dropAfterEffect;
+exports.dropUntil = dropUntil;
+exports.dropUntilEffect = dropUntilEffect;
+exports.dropWhile = dropWhile;
+exports.dropWhileEffect = dropWhileEffect;
+exports.during = during;
+exports.either = either;
+exports.empty = void 0;
+exports.exhaustFilterMapLatestEffect = exhaustFilterMapLatestEffect;
+exports.exhaustMap = exhaustMap;
+exports.exhaustMapCause = exhaustMapCause;
+exports.exhaustMapEffect = exhaustMapEffect;
+exports.exhaustMapError = exhaustMapError;
+exports.exhaustMapLatest = exhaustMapLatest;
+exports.exhaustMapLatestCause = exhaustMapLatestCause;
+exports.exhaustMapLatestEffect = exhaustMapLatestEffect;
+exports.exhaustMapLatestError = exhaustMapLatestError;
+exports.exhaustMatchCause = exhaustMatchCause;
+exports.exhaustMatchError = exhaustMatchError;
+exports.exhaustMatchLatestCause = exhaustMatchLatestCause;
+exports.exhaustMatchLatestError = exhaustMatchLatestError;
+exports.exit = exit;
+exports.filter = exports.failCause = exports.fail = void 0;
+exports.filterCause = filterCause;
+exports.filterCauseEffect = filterCauseEffect;
+exports.filterEffect = void 0;
+exports.filterError = filterError;
+exports.filterErrorEffect = filterErrorEffect;
+exports.filterMap = void 0;
+exports.filterMapCause = filterMapCause;
+exports.filterMapCauseEffect = filterMapCauseEffect;
+exports.filterMapEffect = void 0;
+exports.filterMapError = filterMapError;
+exports.filterMapErrorEffect = filterMapErrorEffect;
+exports.filterMapLoop = void 0;
+exports.filterMapLoopCause = filterMapLoopCause;
+exports.filterMapLoopCauseEffect = filterMapLoopCauseEffect;
+exports.filterMapLoopEffect = void 0;
+exports.filterMapLoopError = filterMapLoopError;
+exports.filterMapLoopErrorEffect = filterMapLoopErrorEffect;
+exports.findFirst = findFirst;
+exports.first = first;
+exports.flatMap = flatMap;
+exports.flatMapCause = flatMapCause;
+exports.flatMapCauseConcurrently = flatMapCauseConcurrently;
+exports.flatMapCauseWithStrategy = flatMapCauseWithStrategy;
+exports.flatMapConcurrently = flatMapConcurrently;
+exports.flatMapConcurrentlyEffect = flatMapConcurrentlyEffect;
+exports.flatMapEffect = flatMapEffect;
+exports.flatMapError = flatMapError;
+exports.flatMapErrorConcurrently = flatMapErrorConcurrently;
+exports.flatMapErrorWithStrategy = flatMapErrorWithStrategy;
+exports.flatMapWithStrategy = flatMapWithStrategy;
+exports.fromArray = void 0;
+exports.fromAsyncIterable = fromAsyncIterable;
+exports.fromEffect = void 0;
+exports.fromFxEffect = fromFxEffect;
+exports.fromSync = exports.fromScheduled = exports.fromIterable = void 0;
+exports.gen = gen;
+exports.genScoped = genScoped;
+exports.if = if_;
+exports.interruptible = void 0;
+exports.isEmpty = isEmpty;
+exports.isFailCause = isFailCause;
+exports.isNever = isNever;
+exports.isPadWith = isPadWith;
+exports.isProducer = isProducer;
+exports.isProducerEffect = isProducerEffect;
+exports.isProducerEffectTransformer = isProducerEffectTransformer;
+exports.isProducerSyncTransformer = isProducerSyncTransformer;
+exports.isSlice = isSlice;
+exports.isTransformer = isTransformer;
+exports.locally = locally;
+exports.locallyWith = locallyWith;
+exports.loop = void 0;
+exports.loopCause = loopCause;
+exports.loopCauseEffect = loopCauseEffect;
+exports.loopEffect = void 0;
+exports.loopError = loopError;
+exports.loopErrorEffect = loopErrorEffect;
+exports.make = make;
+exports.map = void 0;
+exports.mapBoth = mapBoth;
+exports.mapCause = mapCause;
+exports.mapCauseEffect = mapCauseEffect;
+exports.mapEffect = void 0;
+exports.mapError = mapError;
+exports.mapErrorEffect = mapErrorEffect;
+exports.matchCause = matchCause;
+exports.matchCauseConcurrently = matchCauseConcurrently;
+exports.matchCauseWithStrategy = matchCauseWithStrategy;
+exports.matchError = matchError;
+exports.matchErrorConcurrently = matchErrorConcurrently;
+exports.matchErrorWithStrategy = matchErrorWithStrategy;
 exports.merge = merge;
-exports.mergeBuffer = mergeBuffer;
-exports.never = exports.middleware = exports.mergeSwitch = exports.mergeConcurrently = exports.mergeBufferConcurrently = void 0;
-exports.observe = observe;
-exports.provideServiceEffect = exports.provideService = exports.provide = exports.periodic = void 0;
+exports.mergeAll = mergeAll;
+exports.mergeFirst = mergeFirst;
+exports.mergeOrdered = mergeOrdered;
+exports.mergeOrderedConcurrently = mergeOrderedConcurrently;
+exports.mergeRace = mergeRace;
+exports.mergeSwitch = mergeSwitch;
+exports.mergeWithStrategy = mergeWithStrategy;
+exports.middleware = middleware;
+exports.observe = exports.never = void 0;
+exports.onError = onError;
+exports.onExit = onExit;
+exports.onInterrupt = onInterrupt;
+exports.orElse = orElse;
+exports.orElseCause = orElseCause;
+exports.padWith = padWith;
+exports.prepend = prepend;
+exports.prependAll = prependAll;
+exports.provide = provide;
+exports.provideContext = provideContext;
+exports.provideLayer = provideLayer;
+exports.provideRuntime = provideRuntime;
+exports.provideService = provideService;
+exports.provideServiceEffect = provideServiceEffect;
 exports.race = race;
-exports.startWith = exports.snapshot = exports.slice = exports.skipRepeatsWith = exports.skipRepeats = exports.since = exports.scanEffect = exports.scan = exports.reduce = exports.recoverWith = void 0;
+exports.raceAll = raceAll;
+exports.reduce = void 0;
+exports.sample = sample;
+exports.scan = scan;
+exports.scoped = exports.schedule = void 0;
+exports.since = since;
+exports.skipRepeats = skipRepeats;
+exports.skipRepeatsWith = skipRepeatsWith;
+exports.slice = void 0;
+exports.snapshot = snapshot;
+exports.snapshotEffect = snapshotEffect;
 exports.struct = struct;
-exports.succeed = succeed;
-exports.takeUntil = exports.take = exports.sync = exports.switchMatchCause = exports.switchMatch = exports.switchMapError = exports.switchMapCause = exports.switchMap = exports.suspend = void 0;
-exports.tap = exports.takeWhile = void 0;
-exports.toArray = toArray;
-exports.toChunk = toChunk;
-exports.toReadonlyArray = toReadonlyArray;
-exports.withScopedFork = exports.withFlattenStrategy = exports.withEarlyExit = exports.until = void 0;
-var _effect = /*#__PURE__*/require("effect");
+exports.succeed = void 0;
+exports.suspend = suspend;
+exports.switchMap = switchMap;
+exports.switchMapCause = switchMapCause;
+exports.switchMapEffect = switchMapEffect;
+exports.switchMapError = switchMapError;
+exports.switchMatchCause = switchMatchCause;
+exports.switchMatchError = switchMatchError;
+exports.take = void 0;
+exports.takeUntil = takeUntil;
+exports.takeUntilEffect = takeUntilEffect;
+exports.takeWhile = takeWhile;
+exports.takeWhileEffect = takeWhileEffect;
+exports.tapEffect = void 0;
+exports.throttle = throttle;
+exports.throttleLatest = throttleLatest;
+exports.toEnqueue = toEnqueue;
+exports.toReadonlyArray = void 0;
+exports.tuple = tuple;
+exports.uninterruptible = void 0;
+exports.until = until;
+exports.when = when;
+exports.withConcurrency = withConcurrency;
+exports.withConfigProvider = withConfigProvider;
+exports.withLogSpan = withLogSpan;
+exports.withMaxOpsBeforeYield = withMaxOpsBeforeYield;
+exports.withParentSpan = withParentSpan;
+exports.withPrevious = void 0;
+exports.withRequestBatching = withRequestBatching;
+exports.withRequestCache = withRequestCache;
+exports.withRequestCaching = withRequestCaching;
+exports.withScheduler = withScheduler;
+exports.withSpan = withSpan;
+exports.withTracer = withTracer;
+exports.withTracerTiming = withTracerTiming;
+var Context = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@typed/context"));
+var Boolean = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Boolean"));
+var Cause = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Cause"));
+var Clock = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Clock"));
+var Deferred = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Deferred"));
+var Effect = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Effect"));
+var Either = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Either"));
+var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Equal"));
+var ExecutionStrategy = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/ExecutionStrategy"));
+var Exit = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Exit"));
+var Fiber = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Fiber"));
 var _Function = /*#__PURE__*/require("effect/Function");
-var _context = /*#__PURE__*/require("@typed/context");
-var Schedule = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Schedule"));
-var _effectOperator = /*#__PURE__*/require("./effect-operator.js");
-var _helpers = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./helpers.js"));
-var helpers = _helpers;
-var Provide = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./provide.js"));
-var strategies = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./strategies.js"));
-var _syncOperator = /*#__PURE__*/require("./sync-operator.js");
-var Emitter = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("../Emitter.js"));
+var Layer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Layer"));
+var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Option"));
+var Predicate = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Predicate"));
+var Ref = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Ref"));
+var Scope = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Scope"));
+var Tracer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("effect/Tracer"));
 var Sink = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("../Sink.js"));
 var _bounds = /*#__PURE__*/require("./bounds.js");
-var _effectPrimitive = /*#__PURE__*/require("./effect-primitive.js");
-var _fxPrimitive = /*#__PURE__*/require("./fx-primitive.js");
-var _matchers = /*#__PURE__*/require("./matchers.js");
+var EffectLoopOp = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./effect-loop-operator.js"));
+var EffectOp = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./effect-operator.js"));
+var EffectProducer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./effect-producer.js"));
+var _helpers = /*#__PURE__*/require("./helpers.js");
+var SyncLoopOp = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./loop-operator.js"));
+var Op = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./operator.js"));
 var _protos = /*#__PURE__*/require("./protos.js");
-var _run = /*#__PURE__*/require("./run.js");
+var Provide = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./provide.js"));
+var _strategies = /*#__PURE__*/require("./strategies.js");
+var SyncOp = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./sync-operator.js"));
+var SyncProducer = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./sync-producer.js"));
 function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const constUnit = () => _effect.Effect.unit;
-class Merge extends _fxPrimitive.ToFx {
+const DISCARD = {
+  discard: true
+};
+const UNBOUNDED = {
+  concurrency: "unbounded"
+};
+function make(run) {
+  return new Make(run);
+}
+class Make extends _protos.FxBase {
+  _run;
+  constructor(_run) {
+    super();
+    this._run = _run;
+  }
+  run(sink) {
+    return Effect.contextWithEffect(ctx => this._run(Sink.provide(sink, ctx)));
+  }
+}
+class Producer extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return SyncProducer.runSink(this.i0, sink);
+  }
+}
+/**
+ * @internal
+ */
+function isProducer(fx) {
+  return fx.constructor === Producer;
+}
+const succeed = value => new Producer(SyncProducer.Success(value));
+exports.succeed = succeed;
+const fromSync = f => new Producer(SyncProducer.FromSync(f));
+exports.fromSync = fromSync;
+const fromArray = array => new Producer(SyncProducer.FromArray(array));
+exports.fromArray = fromArray;
+const fromIterable = iterable => new Producer(SyncProducer.FromIterable(iterable));
+exports.fromIterable = fromIterable;
+class ProducerEffect extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return EffectProducer.runSink(this.i0, sink);
+  }
+}
+/**
+ * @internal
+ */
+function isProducerEffect(fx) {
+  return fx.constructor === ProducerEffect;
+}
+const fromEffect = effect => (0, _helpers.matchEffectPrimitive)(effect, {
+  // Match over Effect primitives and return Fx primitives to allow fusion to take place
+  Success: succeed,
+  Failure: failCause,
+  Sync: fromSync,
+  Left: fail,
+  Right: succeed,
+  Some: succeed,
+  None: fail,
+  Otherwise: effect => new ProducerEffect(EffectProducer.FromEffect(effect))
+});
+exports.fromEffect = fromEffect;
+const fromScheduled = (input, schedule) => new ProducerEffect(EffectProducer.FromScheduled(input, schedule));
+exports.fromScheduled = fromScheduled;
+const schedule = (input, schedule) => new ProducerEffect(EffectProducer.Scheduled(input, schedule));
+exports.schedule = schedule;
+class FailCause extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return sink.onFailure(this.i0);
+  }
+}
+/**
+ * @internal
+ */
+function isFailCause(fx) {
+  return fx.constructor === FailCause;
+}
+const failCause = cause => new FailCause(cause);
+exports.failCause = failCause;
+const fail = error => failCause(Cause.fail(error));
+exports.fail = fail;
+const die = error => failCause(Cause.die(error));
+exports.die = die;
+class Transformer extends _protos.FxBase {
   i0;
   i1;
   constructor(i0, i1) {
-    super(i0, i1);
+    super();
     this.i0 = i0;
     this.i1 = i1;
   }
-  static make(fx, strategy) {
-    // TODO: Flatten nested Merges
-    if (fx.length === 0) return empty;
-    const nonEmptyFx = fx.filter(fx => !(fx instanceof _fxPrimitive.Empty));
-    if (nonEmptyFx.length === 0) return empty;
-    if (nonEmptyFx.length === 1) return nonEmptyFx[0];
-    const neverIndex = nonEmptyFx.findIndex(fx => fx instanceof _fxPrimitive.Never);
-    if (neverIndex === -1) return new Merge(nonEmptyFx, strategy);
-    switch (strategy._tag) {
-      case "Switch":
-      case "Ordered":
-        // Will only emit up to the first Never
-        return new Merge(nonEmptyFx.slice(0, neverIndex + 1), strategy);
-      // No use creating fibers for Fx that don't emit
-      case "Unordered":
-        return new Merge(nonEmptyFx, strategy);
-    }
+  run(sink) {
+    return this.i0.run(Op.compileOperatorSink(this.i1, sink));
   }
-  toFx() {
-    const {
-      i0,
-      i1
-    } = this;
-    switch (i1._tag) {
-      case "Ordered":
-        {
-          const concurrency = i1.concurrency === Infinity ? "unbounded" : i1.concurrency;
-          return fromSink(sink => _effect.Effect.flatMap(helpers.withBuffers(i0.length, sink), buffers => _effect.Effect.all(i0.map((fx, i) => _effect.Effect.flatMap((0, _run.run)(fx, Sink.WithContext(cause => _effect.Cause.isInterruptedOnly(cause) ? _effect.Effect.unit : sink.onFailure(cause), a => buffers.onSuccess(i, a))), () => buffers.onEnd(i))), {
-            concurrency
-          })));
-        }
-      case "Switch":
-        return fromSink(sink => _effect.Effect.all(i0.map(fx => (0, _run.run)(fx, sink)), {
-          concurrency: 1
-        }));
-      case "Unordered":
-        return fromSink(sink => _effect.Effect.all(i0.map(fx => (0, _run.run)(fx, sink)), {
-          concurrency: i1.concurrency === Infinity ? "unbounded" : i1.concurrency
-        }));
+  static make(fx, operator) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else if (isProducer(fx)) {
+      return new ProducerSyncTransformer(fx.i0, operator);
+    } else if (isTransformer(fx)) {
+      return new Transformer(fx.i0, Op.fuseOperators(fx.i1, operator));
+    } else if (isProducerSyncTransformer(fx)) {
+      return new ProducerSyncTransformer(fx.i0, Op.fuseOperators(fx.i1, operator));
+    } else if (isProducerEffect(fx)) {
+      return new ProducerEffectTransformer(fx.i0, operator);
+    } else if (isProducerEffectTransformer(fx)) {
+      return new ProducerEffectTransformer(fx.i0, Op.fuseOperators(fx.i1, operator));
+    } else if (isSuspend(fx)) {
+      return new SuspendedTransformer(fx.i0, operator);
+    } else if (isSuspendedTransformer(fx)) {
+      return new SuspendedTransformer(fx.i0, Op.fuseOperators(fx.i1, operator));
+    } else if (isFailCause(fx)) {
+      return fx;
+    } else {
+      return new Transformer(fx, operator);
     }
   }
 }
-class Slice extends _fxPrimitive.ToFx {
+/**
+ * @internal
+ */
+function isTransformer(fx) {
+  return fx.constructor === Transformer;
+}
+class ProducerSyncTransformer extends _protos.FxBase {
   i0;
   i1;
   constructor(i0, i1) {
-    super(i0, i1);
+    super();
     this.i0 = i0;
     this.i1 = i1;
   }
-  static make(fx, bounds) {
-    if (fx instanceof Slice) {
-      return new Slice(fx.i0, (0, _bounds.mergeBounds)(fx.i1, bounds));
-    } else if (fx instanceof _fxPrimitive.Transformer && fx.i1._tag === "Map") {
-      return new _fxPrimitive.Transformer(Slice.make(fx.i0, bounds), fx.i1);
+  run(sink) {
+    return SyncProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink));
+  }
+}
+/**
+ * @internal
+ */
+function isProducerSyncTransformer(fx) {
+  return fx.constructor === ProducerSyncTransformer;
+}
+const map = (fx, f) => Transformer.make(fx, SyncOp.Map(f));
+exports.map = map;
+const filter = (fx, f) => Transformer.make(fx, SyncOp.Filter(f));
+exports.filter = filter;
+const filterMap = (fx, f) => Transformer.make(fx, SyncOp.FilterMap(f));
+exports.filterMap = filterMap;
+const mapEffect = (fx, f) => Transformer.make(fx, EffectOp.MapEffect(f));
+exports.mapEffect = mapEffect;
+const filterMapEffect = (fx, f) => Transformer.make(fx, EffectOp.FilterMapEffect(f));
+exports.filterMapEffect = filterMapEffect;
+const filterEffect = (fx, f) => Transformer.make(fx, EffectOp.FilterEffect(f));
+exports.filterEffect = filterEffect;
+const tapEffect = (fx, f) => Transformer.make(fx, EffectOp.TapEffect(f));
+exports.tapEffect = tapEffect;
+const loop = (fx, seed, f) => Transformer.make(fx, SyncLoopOp.LoopOperator(seed, f));
+exports.loop = loop;
+const withPrevious = fx => loop(fx, Option.none(), (acc, a) => [[acc, a], Option.some(a)]);
+exports.withPrevious = withPrevious;
+const filterMapLoop = (fx, seed, f) => Transformer.make(fx, SyncLoopOp.FilterMapLoopOperator(seed, f));
+exports.filterMapLoop = filterMapLoop;
+const loopEffect = (fx, seed, f) => Transformer.make(fx, EffectLoopOp.LoopEffectOperator(seed, f));
+exports.loopEffect = loopEffect;
+const filterMapLoopEffect = (fx, seed, f) => Transformer.make(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f));
+exports.filterMapLoopEffect = filterMapLoopEffect;
+const observe = (fx, f) => Observe.make(fx, f);
+exports.observe = observe;
+const constUnit = () => Effect.unit;
+const drain = fx => Observe.make(fx, constUnit);
+exports.drain = drain;
+class Observe extends _protos.EffectBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  toEffect() {
+    return Effect.asyncEffect(resume => {
+      const {
+        i0: fx,
+        i1: f
+      } = this;
+      const onFailure = cause => Effect.sync(() => resume(Effect.failCause(cause)));
+      return Effect.zipRight(fx.run(Sink.make(onFailure, a => Effect.catchAllCause(f(a), onFailure))), Effect.sync(() => resume(Effect.unit)));
+    });
+  }
+  static make(fx, f) {
+    if (isEmpty(fx)) {
+      return Effect.unit;
+    } else if (isNever(fx)) {
+      return Effect.never;
+    } else if (isProducer(fx)) {
+      return SyncProducer.runEffect(fx.i0, f);
+    } else if (isProducerSyncTransformer(fx)) {
+      return Op.matchOperator(fx.i1, {
+        SyncOperator: op => SyncOp.matchSyncOperator(op, {
+          Map: op => SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, a => f(op.f(a)))),
+          Filter: op => SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, Effect.unifiedFn(a => op.f(a) ? f(a) : Effect.unit))),
+          FilterMap: op => SyncProducer.effectOnce(() => SyncProducer.runEffect(fx.i0, Effect.unifiedFn(a => Option.match(op.f(a), {
+            onNone: () => Effect.unit,
+            onSome: f
+          }))))
+        }),
+        EffectOperator: op => EffectOp.matchEffectOperator(op, {
+          MapEffect: op => SyncProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), f)),
+          FilterMapEffect: op => SyncProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), Effect.unifiedFn(Option.match({
+            onNone: () => Effect.unit,
+            onSome: f
+          })))),
+          FilterEffect: op => SyncProducer.runEffect(fx.i0, Effect.unifiedFn(a => Effect.flatMap(op.f(a), Effect.unifiedFn(b => b ? f(a) : Effect.unit)))),
+          TapEffect: op => SyncProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), () => f(a)))
+        }),
+        SyncLoopOperator: op => SyncLoopOp.matchSyncLoopOperator(op, {
+          Loop: op => SyncProducer.effectOnce(() => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+            const [c, b] = op.f(acc, a);
+            return Effect.as(f(c), b);
+          })),
+          FilterMapLoop: op => SyncProducer.effectOnce(() => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+            const [c, b] = op.f(acc, a);
+            return Option.match(c, {
+              onNone: () => Effect.succeed(acc),
+              onSome: c => Effect.as(f(c), b)
+            });
+          }))
+        }),
+        EffectLoopOperator: op => EffectLoopOp.matchEffectLoopOperator(op, {
+          LoopEffect: op => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Effect.as(f(c), b))),
+          FilterMapLoopEffect: op => SyncProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Option.match(c, {
+            onNone: () => Effect.succeed(b),
+            onSome: c => Effect.as(f(c), b)
+          })))
+        })
+      });
+    } else if (isProducerEffect(fx)) {
+      return EffectProducer.runEffect(fx.i0, f);
+    } else if (isProducerEffectTransformer(fx)) {
+      return Op.matchOperator(fx.i1, {
+        SyncOperator: op => SyncOp.matchSyncOperator(op, {
+          Map: op => SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, a => f(op.f(a)))),
+          Filter: op => SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, Effect.unifiedFn(a => op.f(a) ? f(a) : Effect.unit))),
+          FilterMap: op => SyncProducer.effectOnce(() => EffectProducer.runEffect(fx.i0, Effect.unifiedFn(a => Option.match(op.f(a), {
+            onNone: () => Effect.unit,
+            onSome: f
+          }))))
+        }),
+        EffectOperator: op => EffectOp.matchEffectOperator(op, {
+          MapEffect: op => EffectProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), f)),
+          FilterMapEffect: op => EffectProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), Effect.unifiedFn(Option.match({
+            onNone: () => Effect.unit,
+            onSome: f
+          })))),
+          FilterEffect: op => EffectProducer.runEffect(fx.i0, Effect.unifiedFn(a => Effect.flatMap(op.f(a), Effect.unifiedFn(b => b ? f(a) : Effect.unit)))),
+          TapEffect: op => EffectProducer.runEffect(fx.i0, a => Effect.flatMap(op.f(a), () => f(a)))
+        }),
+        SyncLoopOperator: op => SyncLoopOp.matchSyncLoopOperator(op, {
+          Loop: op => SyncProducer.effectOnce(() => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+            const [c, b] = op.f(acc, a);
+            return Effect.as(f(c), b);
+          })),
+          FilterMapLoop: op => SyncProducer.effectOnce(() => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => {
+            const [c, b] = op.f(acc, a);
+            return Option.match(c, {
+              onNone: () => Effect.succeed(acc),
+              onSome: c => Effect.as(f(c), b)
+            });
+          }))
+        }),
+        EffectLoopOperator: op => EffectLoopOp.matchEffectLoopOperator(op, {
+          LoopEffect: op => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Effect.as(f(c), b))),
+          FilterMapLoopEffect: op => EffectProducer.runReduceEffect(fx.i0, op.seed, (acc, a) => Effect.flatMap(op.f(acc, a), ([c, b]) => Option.match(c, {
+            onNone: () => Effect.succeed(b),
+            onSome: c => Effect.as(f(c), b)
+          })))
+        })
+      });
+    } else if (isFailCause(fx)) {
+      return Effect.failCause(fx.i0);
     } else {
-      return new Slice(fx, bounds);
+      return new Observe(fx, f);
     }
   }
-  toFx() {
-    const fx = this.i0;
-    const {
-      max,
-      min
-    } = this.i1;
-    return withEarlyExit(({
-      sink
-    }) => _effect.Effect.suspend(() => {
-      let toSkip = min;
-      let toTake = max;
-      return (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => _effect.Effect.suspend(() => {
-        if (toSkip > 0) {
-          toSkip -= 1;
-          return _effect.Effect.unit;
-        } else if (toTake > 0) {
-          toTake -= 1;
-          return _effect.Effect.flatMap(sink.onSuccess(a), () => toTake <= 0 ? sink.earlyExit : _effect.Effect.unit);
-        } else {
-          return sink.earlyExit;
-        }
-      })));
-    }));
-  }
-}
-class Loop extends _fxPrimitive.ToFx {
+}
+const reduce = (fx, seed, f) => Reduce.make(fx, seed, f);
+exports.reduce = reduce;
+class Reduce extends _protos.EffectBase {
   i0;
   i1;
   i2;
   constructor(i0, i1, i2) {
-    super(i0, i1, i2);
+    super();
     this.i0 = i0;
     this.i1 = i1;
     this.i2 = i2;
   }
-  static make(fx, b, f) {
-    if (fx instanceof _fxPrimitive.Transformer) {
-      return FilterMapLoop.make(fx.i0, b, (0, _syncOperator.compileSyncReducer)(fx.i1, f));
-    } else if (fx instanceof _fxPrimitive.TransformerEffect) {
-      return new FilterMapLoopEffect(fx.i0, b, (0, _effectOperator.compileEffectLoop)(fx.i1, (b, a) => _effect.Effect.sync(() => f(b, a))));
+  toEffect() {
+    return Effect.suspend(() => {
+      let acc = this.i1;
+      return Effect.map(observe(this.i0, a => Effect.sync(() => acc = this.i2(acc, a))), () => acc);
+    });
+  }
+  static make(fx, seed, f) {
+    // TODO: optimize Effect trasformers
+    if (isEmpty(fx)) return Effect.succeed(seed);else if (isProducer(fx)) {
+      return SyncProducer.runReduce(fx.i0, seed, f);
+    } else if (isProducerSyncTransformer(fx)) {
+      return Op.matchOperator(fx.i1, {
+        SyncOperator: op => SyncProducer.syncOnce(() => SyncOp.runSyncReduce(fx.i0, op, seed, f)),
+        EffectOperator: op => EffectOp.runSyncReduce(fx.i0, op, seed, f),
+        SyncLoopOperator: op => SyncLoopOp.matchSyncLoopOperator(op, {
+          Loop: op => Effect.map(SyncProducer.runReduce(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
+            const [c, b] = op.f(opAcc, a);
+            const newAcc = f(acc, c);
+            return [b, newAcc];
+          }), x => x[1]),
+          FilterMapLoop: op => Effect.map(SyncProducer.runReduce(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
+            const [c, b] = op.f(opAcc, a);
+            const newAcc = Option.match(c, {
+              onNone: () => acc,
+              onSome: c => f(acc, c)
+            });
+            return [b, newAcc];
+          }), x => x[1])
+        }),
+        EffectLoopOperator: op => EffectLoopOp.matchEffectLoopOperator(op, {
+          LoopEffect: op => Effect.map(SyncProducer.runReduceEffect(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
+            return Effect.flatMap(op.f(opAcc, a), ([c, b]) => {
+              const newAcc = f(acc, c);
+              return Effect.succeed([b, newAcc]);
+            });
+          }), x => x[1]),
+          FilterMapLoopEffect: op => Effect.map(SyncProducer.runReduceEffect(fx.i0, [op.seed, seed], ([opAcc, acc], a) => {
+            return Effect.map(op.f(opAcc, a), ([c, b]) => {
+              const newAcc = Option.match(c, {
+                onNone: () => acc,
+                onSome: () => f(acc, b)
+              });
+              return [b, newAcc];
+            });
+          }), x => x[1])
+        })
+      });
+    } else if (isProducerEffect(fx)) {
+      return EffectProducer.runReduceEffect(fx.i0, seed, (b, a) => Effect.succeed(f(b, a)));
+    } else if (isFailCause(fx)) {
+      return Effect.failCause(fx.i0);
     } else {
-      return new Loop(fx, f, b);
+      return new Reduce(fx, seed, f);
     }
   }
-  toFx() {
-    return fromSink(sink => _effect.Effect.suspend(() => {
-      let acc = this.i2;
-      return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => _effect.Effect.suspend(() => {
-        const [c, b] = this.i1(acc, a);
-        acc = b;
-        return sink.onSuccess(c);
-      })));
-    }));
+}
+const toReadonlyArray = fx => Effect.suspend(() => {
+  const init = [];
+  return Reduce.make(fx, init, (acc, a) => {
+    acc.push(a);
+    return acc;
+  });
+});
+exports.toReadonlyArray = toReadonlyArray;
+const slice = (fx, drop, take) => Slice.make(fx, (0, _bounds.boundsFrom)(drop, take));
+exports.slice = slice;
+const take = (fx, n) => slice(fx, 0, n);
+exports.take = take;
+const drop = (fx, n) => slice(fx, n, Infinity);
+exports.drop = drop;
+class Slice extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return Sink.slice(sink, this.i1, s => this.i0.run(s));
+  }
+  static make(fx, bounds) {
+    if ((0, _bounds.isNilBounds)(bounds)) return empty;
+    if ((0, _bounds.isInfiniteBounds)(bounds)) return fx;
+    if (isSlice(fx)) {
+      return Slice.make(fx.i0, (0, _bounds.mergeBounds)(fx.i1, bounds));
+    } else if (isTransformer(fx) && fx.i1._tag === "Map") {
+      // Commute map and slice
+      return map(Slice.make(fx.i0, bounds), fx.i1.f);
+    } else {
+      return new Slice(fx, bounds);
+    }
   }
 }
-class FilterMapLoop extends _fxPrimitive.ToFx {
+/**
+ * @internal
+ */
+function isSlice(fx) {
+  return fx.constructor === Slice;
+}
+function skipRepeatsWith(fx, eq) {
+  return filterMapLoop(fx, Option.none(), (previous, a) => {
+    if (Option.isSome(previous) && eq(a, previous.value)) {
+      return [Option.none(), Option.some(a)];
+    } else {
+      return [Option.some(a), Option.some(a)];
+    }
+  });
+}
+function skipRepeats(fx) {
+  return skipRepeatsWith(fx, Equal.equals);
+}
+class ProducerEffectTransformer extends _protos.FxBase {
   i0;
   i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super(i0, i1, i2);
+  constructor(i0, i1) {
+    super();
     this.i0 = i0;
     this.i1 = i1;
-    this.i2 = i2;
   }
-  static make(fx, b, f) {
-    return new FilterMapLoop(fx, b, f);
+  run(sink) {
+    return EffectProducer.runSink(this.i0, Op.compileOperatorSink(this.i1, sink));
   }
-  toFx() {
-    return fromSink(sink => _effect.Effect.suspend(() => {
-      let acc = this.i1;
-      return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => _effect.Effect.suspend(() => {
-        const optionCB = this.i2(acc, a);
-        if (_effect.Option.isNone(optionCB)) return _effect.Effect.unit;
-        const [c, b] = optionCB.value;
-        acc = b;
-        return sink.onSuccess(c);
-      })));
-    }));
+}
+/**
+ * @internal
+ */
+function isProducerEffectTransformer(fx) {
+  return fx.constructor === ProducerEffectTransformer;
+}
+class Empty extends _protos.FxBase {
+  run() {
+    return Effect.unit;
   }
 }
-class LoopEffect extends _fxPrimitive.ToFx {
+/**
+ * @internal
+ */
+function isEmpty(fx) {
+  return fx.constructor === Empty;
+}
+const empty = exports.empty = /*#__PURE__*/new Empty();
+class Never extends _protos.FxBase {
+  run() {
+    return Effect.never;
+  }
+}
+/**
+ * @internal
+ */
+function isNever(fx) {
+  return fx.constructor === Never;
+}
+const never = exports.never = /*#__PURE__*/new Never();
+function padWith(fx, start, end) {
+  return new PadWith(fx, start, end);
+}
+function prependAll(fx, start) {
+  return new PadWith(fx, start, []);
+}
+function appendAll(fx, end) {
+  return new PadWith(fx, [], end);
+}
+function prepend(fx, start) {
+  return new PadWith(fx, [start], []);
+}
+function append(fx, end) {
+  return new PadWith(fx, [], [end]);
+}
+function scan(fx, seed, f) {
+  return prepend(loop(fx, seed, (b, a) => {
+    const b2 = f(b, a);
+    return [b2, b2];
+  }), seed);
+}
+class PadWith extends _protos.FxBase {
   i0;
   i1;
   i2;
   constructor(i0, i1, i2) {
-    super(i0, i1, i2);
+    super();
     this.i0 = i0;
     this.i1 = i1;
     this.i2 = i2;
   }
-  static make(fx, f, b) {
-    if (fx instanceof _fxPrimitive.TransformerEffect) {
-      return new FilterMapLoopEffect(fx.i0, b, (0, _effectOperator.compileEffectLoop)(fx.i1, f));
-    } else if (fx instanceof _fxPrimitive.Transformer) {
-      return new FilterMapLoopEffect(fx.i0, b, (0, _effectOperator.compileEffectLoop)((0, _effectOperator.liftSyncOperator)(fx.i1), f));
+  run(sink) {
+    const onSuccess = a => sink.onSuccess(a);
+    return Effect.forEach(this.i1, onSuccess, DISCARD).pipe(Effect.zipRight(this.i0.run(sink)), Effect.zipRight(Effect.forEach(this.i2, onSuccess, DISCARD)));
+  }
+  static make(fx, start, end) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else if (isPadWith(fx)) {
+      return new PadWith(fx.i0, concat(start, fx.i1), concat(fx.i2, end));
     } else {
-      return new LoopEffect(fx, f, b);
+      return new PadWith(fx, start, end);
     }
   }
-  toFx() {
-    const {
-      i0,
-      i1,
-      i2
-    } = this;
-    return fromSink(sink => _effect.Effect.flatMap(_effect.SynchronizedRef.make(i2), ref => (0, _run.run)(i0, Sink.WithContext(sink.onFailure, a => _effect.SynchronizedRef.updateEffect(ref, b => _effect.Effect.matchCauseEffect(i1(b, a), {
-      onFailure: cause => _effect.Effect.as(sink.onFailure(cause), b),
-      onSuccess: ([c, b2]) => _effect.Effect.as(sink.onSuccess(c), b2)
-    }))))));
-  }
 }
-class FilterMapLoopEffect extends _fxPrimitive.ToFx {
+function concat(a, b) {
+  return {
+    *[Symbol.iterator]() {
+      yield* a;
+      yield* b;
+    }
+  };
+}
+/**
+ * @internal
+ */
+function isPadWith(fx) {
+  return fx.constructor === PadWith;
+}
+function flatMapWithStrategy(fx, f, strategy, executionStrategy = ExecutionStrategy.sequential) {
+  return FlatMapWithStrategy.make(fx, f, strategy, executionStrategy);
+}
+function switchMap(fx, f, executionStrategy) {
+  return flatMapWithStrategy(fx, f, _strategies.Switch, executionStrategy);
+}
+function switchMapEffect(fx, f, executionStrategy) {
+  return switchMap(fx, a => fromEffect(f(a)), executionStrategy);
+}
+function exhaustMap(fx, f, executionStrategy) {
+  return flatMapWithStrategy(fx, f, _strategies.Exhaust, executionStrategy);
+}
+function exhaustMapEffect(fx, f, executionStrategy) {
+  return exhaustMap(fx, a => fromEffect(f(a)), executionStrategy);
+}
+function exhaustMapLatest(fx, f, executionStrategy) {
+  return flatMapWithStrategy(fx, f, _strategies.ExhaustLatest, executionStrategy);
+}
+function exhaustMapLatestEffect(fx, f, executionStrategy) {
+  return exhaustMapLatest(fx, a => fromEffect(f(a)), executionStrategy);
+}
+function exhaustFilterMapLatestEffect(fx, f, executionStrategy) {
+  return exhaustMapLatest(fx, a => fromFxEffect(Effect.map(f(a), Option.match({
+    onNone: () => empty,
+    onSome: succeed
+  }))), executionStrategy);
+}
+function flatMapConcurrently(fx, f, capacity, executionStrategy) {
+  return flatMapWithStrategy(fx, f, (0, _strategies.Bounded)(capacity), executionStrategy);
+}
+function concatMap(fx, f, executionStrategy) {
+  return flatMapConcurrently(fx, f, 1, executionStrategy);
+}
+function flatMapConcurrentlyEffect(fx, f, capacity, executionStrategy) {
+  return flatMapConcurrently(fx, a => fromEffect(f(a)), capacity, executionStrategy);
+}
+function flatMap(fx, f, executionStrategy) {
+  return flatMapWithStrategy(fx, f, _strategies.Unbounded, executionStrategy);
+}
+function flatMapEffect(fx, f, executionStrategy) {
+  return flatMap(fx, a => fromEffect(f(a)), executionStrategy);
+}
+class FlatMapWithStrategy extends _protos.FxBase {
   i0;
   i1;
   i2;
-  constructor(i0, i1, i2) {
-    super(i0, i1, i2);
+  i3;
+  withFork;
+  constructor(i0, i1, i2, i3) {
+    super();
     this.i0 = i0;
     this.i1 = i1;
     this.i2 = i2;
+    this.i3 = i3;
+    this.withFork = (0, _helpers.withFlattenStrategy)(i2);
   }
-  toFx() {
-    return fromSink(sink => _effect.Effect.suspend(() => {
-      let acc = this.i1;
-      return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => this.i2(acc, a).pipe(_effect.Effect.matchCauseEffect({
-        onFailure: sink.onFailure,
-        onSuccess: optionCB => _effect.Effect.suspend(() => {
-          if (_effect.Option.isNone(optionCB)) return _effect.Effect.unit;
-          const [c, b] = optionCB.value;
-          acc = b;
-          return sink.onSuccess(c);
-        })
-      }))));
-    }));
+  run(sink) {
+    return this.withFork(fork => Sink.withEarlyExit(sink, sink => this.i0.run(Sink.make(cause => Cause.isInterruptedOnly(cause) ? sink.earlyExit : sink.onFailure(cause), a => fork(this.i1(a).run(sink))))), this.i3);
+  }
+  static make(fx, f, strategy, executionStrategy) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else if (isProducer(fx)) {
+      if (fx.i0._tag === "Success") return f(fx.i0.source);
+      if (fx.i0._tag === "FromSync") {
+        const producer = fx.i0;
+        return suspend(() => f(producer.source()));
+      }
+      const arr = Array.isArray(fx.i0.source) ? fx.i0.source : Array.from(fx.i0.source);
+      if (arr.length === 0) return empty;
+      if (arr.length === 1) return f(arr[0]);
+      switch (strategy._tag) {
+        case "Switch":
+          return f(arr[arr.length - 1]);
+        case "Exhaust":
+          return f(arr[0]);
+        case "ExhaustLatest":
+          return arr.length > 1 ? continueWith(f(arr[0]), () => f(arr[arr.length - 1])) : f(arr[0]);
+        default:
+          return new FlatMapWithStrategy(fx, f, strategy, executionStrategy);
+      }
+    } else if (isProducerEffect(fx) && fx.i0._tag === "FromEffect") {
+      return fromFxEffect(Effect.map(fx.i0.source, f));
+    } else if (isTransformer(fx) && fx.i1._tag === "Map") {
+      const {
+        f: op
+      } = fx.i1;
+      return new FlatMapWithStrategy(fx.i0, a => f(op(a)), strategy, executionStrategy);
+    } else {
+      return new FlatMapWithStrategy(fx, f, strategy, executionStrategy);
+    }
+  }
+}
+function fromFxEffect(effect) {
+  return new FromFxEffect(effect);
+}
+class FromFxEffect extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return Effect.matchCauseEffect(this.i0, {
+      onFailure: cause => sink.onFailure(cause),
+      onSuccess: fx => fx.run(sink)
+    });
   }
 }
-class FxProvide extends _fxPrimitive.ToFx {
+function gen(f) {
+  return fromFxEffect(Effect.gen(f));
+}
+function genScoped(f) {
+  return scoped(fromFxEffect(Effect.gen(f)));
+}
+function continueWith(fx, f) {
+  return ContinueWith.make(fx, f);
+}
+class ContinueWith extends _protos.FxBase {
   i0;
   i1;
   constructor(i0, i1) {
-    super(i0, i1);
+    super();
     this.i0 = i0;
     this.i1 = i1;
   }
-  static make(fx, provide) {
-    if (fx instanceof FxProvide) {
-      return new FxProvide(fx.i0, Provide.merge(fx.i1, provide));
+  run(sink) {
+    return Effect.flatMap(this.i0.run(sink), () => this.i1().run(sink));
+  }
+  static make(fx, f) {
+    if (isEmpty(fx)) return f();else if (isNever(fx)) return fx;else if (isProducer(fx)) {
+      return SyncProducer.matchSyncProducer(fx.i0, {
+        Success: source => prependAll(f(), [source]),
+        FromSync: source => suspend(() => prependAll(f(), [source()])),
+        FromArray: source => prependAll(f(), source),
+        FromIterable: source => prependAll(f(), source)
+      });
     } else {
-      return new FxProvide(fx, provide);
+      return new ContinueWith(fx, f);
     }
   }
-  toFx() {
-    return fromSink(sink => _effect.Effect.catchAllCause(Provide.provideToEffect((0, _run.run)(this.i0, sink), this.i1), sink.onFailure));
-  }
 }
-class Snapshot extends _fxPrimitive.ToFx {
+function orElseCause(fx, f) {
+  return OrElseCause.make(fx, f);
+}
+class OrElseCause extends _protos.FxBase {
   i0;
   i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super(i0, i1, i2);
+  constructor(i0, i1) {
+    super();
     this.i0 = i0;
     this.i1 = i1;
-    this.i2 = i2;
   }
-  toFx() {
-    return (0, _matchers.matchFxInput)(this.i1, {
-      RefSubject: fx2 => this.runScoped(this.i0, fx2, this.i2),
-      Fx: fx2 => this.runScoped(this.i0, fx2, this.i2),
-      Effect: effect2 => mapEffect(this.i0, a => _effect.Effect.flatMap(effect2, b => this.i2(a, b))),
-      Cause: cause2 => matchCause(this.i0, {
-        onFailure: cause1 => _effect.Effect.failCause(_effect.Cause.sequential(cause1, cause2)),
-        onSuccess: () => _effect.Effect.failCause(cause2)
-      }),
-      Iterable: iterable => withEarlyExit(({
-        sink
-      }) => {
-        const iterator = iterable[Symbol.iterator]();
-        return (0, _run.run)(this.i0, Sink.WithContext(sink.onFailure, a => {
-          const result = iterator.next();
-          if (result.done) {
-            return sink.earlyExit;
-          } else {
-            return _effect.Effect.matchCauseEffect(this.i2(a, result.value), sink);
-          }
-        }));
-      }),
-      Otherwise: b => mapEffect(this.i0, a => this.i2(a, b))
-    });
+  run(sink) {
+    return Effect.catchAllCause(observe(this.i0, sink.onSuccess), cause => this.i1(cause).run(sink));
   }
-  runScoped(fx, fx2, f) {
-    return withScopedFork(({
-      fork,
-      sink
-    }) => _effect.Effect.flatMap(_effect.Ref.make(_effect.Option.none()), ref => _effect.Effect.flatMap(fork((0, _run.run)(fx2, Sink.WithContext(sink.onFailure, b => _effect.Ref.set(ref, _effect.Option.some(b))))), () => (0, _helpers.adjustTime)(1).pipe(_effect.Effect.zipRight((0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => _effect.Effect.flatten(_effect.Ref.get(ref)).pipe(_effect.Effect.flatMap(b => _effect.Effect.matchCauseEffect(f(a, b), sink)), _effect.Effect.optionFromOptional, _effect.Effect.asUnit))))))));
+  static make(fx, f) {
+    if (isEmpty(fx)) return fx;else if (isNever(fx)) return fx;else {
+      return new OrElseCause(fx, f);
+    }
   }
 }
-class Middleware extends _fxPrimitive.ToFx {
+function orElse(fx, f) {
+  return OrElse.make(fx, f);
+}
+class OrElse extends _protos.FxBase {
   i0;
   i1;
-  i2;
-  constructor(i0, i1, i2) {
-    super(i0, i1);
+  constructor(i0, i1) {
+    super();
     this.i0 = i0;
     this.i1 = i1;
-    this.i2 = i2;
   }
-  static make(fx, middleware, mapSink) {
-    if (fx instanceof Middleware) {
-      return new Middleware(fx.i0, effect => middleware(fx.i1(effect)), s => fx.i2(mapSink(s)));
-    } else {
-      return new Middleware(fx, middleware, mapSink);
+  run(sink) {
+    return Effect.catchAll(Effect.asyncEffect(resume => Effect.zipRight(this.i0.run(Sink.make(cause => Either.match(Cause.failureOrCause(cause), {
+      onLeft: e => Effect.succeed(resume(Effect.fail(e))),
+      onRight: cause => sink.onFailure(cause)
+    }), sink.onSuccess)), Effect.sync(() => resume(Effect.unit)))), error => this.i1(error).run(sink));
+  }
+  static make(fx, f) {
+    if (isEmpty(fx)) return fx;else if (isNever(fx)) return fx;else {
+      return new OrElse(fx, f);
     }
   }
-  toFx() {
-    return fromSink(sink => this.i1((0, _run.run)(this.i0, this.i2(sink))));
+}
+function suspend(f) {
+  return new Suspend(f);
+}
+class Suspend extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return this.i0().run(sink);
+  }
+}
+function isSuspend(fx) {
+  return fx.constructor === Suspend;
+}
+class SuspendedTransformer extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return this.i0().run(Op.compileOperatorSink(this.i1, sink));
   }
 }
-function succeed(value) {
-  return new _fxPrimitive.Succeed(value);
+function isSuspendedTransformer(fx) {
+  return fx.constructor === SuspendedTransformer;
 }
-function fromIterable(iterable) {
-  return new _fxPrimitive.FromIterable(iterable);
+function mergeWithStrategy(fx, stategy) {
+  return MergeWithStrategy.make(fx, stategy);
 }
-const map = exports.map = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return _fxPrimitive.Transformer.make(fx, (0, _syncOperator.Map)(f));
-});
-const mapBoth = exports.mapBoth = /*#__PURE__*/(0, _Function.dual)(2, function mapBoth(fx, options) {
-  return map(mapError(fx, options.onFailure), options.onSuccess);
-});
-const filter = exports.filter = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return _fxPrimitive.Transformer.make(fx, (0, _syncOperator.Filter)(f));
-});
-const filterMap = exports.filterMap = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return _fxPrimitive.Transformer.make(fx, (0, _syncOperator.FilterMap)(f));
-});
-const compact = fx => filterMap(fx, _Function.identity);
-exports.compact = compact;
-const mapErrorCause = exports.mapErrorCause = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.Map)(f));
-});
-const mapError = exports.mapError = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.Map)(_effect.Cause.map(f)));
-});
-const filterCause = exports.filterCause = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.Filter)(f));
-});
-const filterMapCause = exports.filterMapCause = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return _fxPrimitive.TransformerCause.make(fx, (0, _syncOperator.FilterMap)(f));
-});
-const filterError = exports.filterError = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return filterMapCause(fx, cause => _effect.Cause.failureOrCause(cause).pipe(_effect.Either.match({
-    onLeft: e => f(e) ? _effect.Option.some(_effect.Cause.fail(e)) : _effect.Option.none(),
-    onRight: _effect.Option.some
-  })));
-});
-const filterMapError = exports.filterMapError = /*#__PURE__*/(0, _Function.dual)(2, function map(fx, f) {
-  return filterMapCause(fx, cause => _effect.Cause.failureOrCause(cause).pipe(_effect.Either.match({
-    onLeft: e => _effect.Option.map(f(e), _effect.Cause.fail),
-    onRight: _effect.Option.some
-  })));
-});
-const filterMapErrorEffect = exports.filterMapErrorEffect = /*#__PURE__*/(0, _Function.dual)(2, (fx, f) => {
-  return fromSink(sink => (0, _run.run)(fx, Sink.WithContext(cause => _effect.Either.match(_effect.Cause.failureOrCause(cause), {
-    onLeft: e => _effect.Effect.matchCauseEffect(f(e), {
-      onFailure: sink.onFailure,
-      onSuccess: _effect.Option.match({
-        onNone: () => _effect.Effect.unit,
-        onSome: b => sink.onFailure(_effect.Cause.fail(b))
-      })
-    }),
-    onRight: sink.onFailure
-  }), sink.onSuccess)));
-});
-function observe(fx, onSuccees) {
-  return helpers.withScopedFork(fork => _effect.Effect.flatMap(_effect.Deferred.make(), deferred => (0, _run.run)(fx, Sink.WithContext(cause => _effect.Deferred.failCause(deferred, cause), a => _effect.Effect.catchAllCause(onSuccees(a), cause => _effect.Deferred.failCause(deferred, cause)))).pipe(_effect.Effect.intoDeferred(deferred), fork, _effect.Effect.flatMap(() => _effect.Deferred.await(deferred)))));
+function merge(fx, other) {
+  return mergeWithStrategy([fx, other], (0, _strategies.Unordered)(2));
 }
-function drain(fx) {
-  return observe(fx, constUnit);
+function mergeAll(fx) {
+  return mergeWithStrategy(fx, (0, _strategies.Unordered)(Infinity));
 }
-function toArray(fx) {
-  return _effect.Effect.suspend(() => {
-    const array = [];
-    return _effect.Effect.as(observe(fx, a => _effect.Effect.sync(() => array.push(a))), array);
-  });
+function mergeOrdered(fx) {
+  return mergeOrderedConcurrently(fx, Infinity);
 }
-function toReadonlyArray(fx) {
-  return toArray(fx);
+function mergeOrderedConcurrently(fx, concurrency) {
+  return mergeWithStrategy(fx, (0, _strategies.Ordered)(concurrency));
 }
-const flatMapWithStrategy = exports.flatMapWithStrategy = /*#__PURE__*/(0, _Function.dual)(3, function flatMapWithStrategy(fx, f, strategy) {
-  return new _fxPrimitive.WithFlattenStrategy(({
-    fork,
-    sink
-  }) => (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => fork((0, _run.run)(from(f(a)), sink)))), strategy);
-});
-const switchMap = exports.switchMap = /*#__PURE__*/(0, _Function.dual)(2, function switchMap(fx, f) {
-  return flatMapWithStrategy(fx, f, strategies.Switch);
-});
-const exhaustMap = exports.exhaustMap = /*#__PURE__*/(0, _Function.dual)(2, function exhaustmap(fx, f) {
-  return flatMapWithStrategy(fx, f, strategies.Exhaust);
-});
-const exhaust = fx => exhaustMap(fx, _Function.identity);
-exports.exhaust = exhaust;
-const exhaustMapLatest = exports.exhaustMapLatest = /*#__PURE__*/(0, _Function.dual)(2, function exhaustMapLatest(fx, f) {
-  return flatMapWithStrategy(fx, f, strategies.ExhaustLatest);
-});
-const exhaustLatest = fx => exhaustMapLatest(fx, _Function.identity);
-exports.exhaustLatest = exhaustLatest;
-const flatMap = exports.flatMap = /*#__PURE__*/(0, _Function.dual)(2, function flatMap(fx, f) {
-  return flatMapWithStrategy(fx, f, strategies.Unbounded);
-});
-const flatten = fx => flatMap(fx, _Function.identity);
-exports.flatten = flatten;
-const flatMapConcurrently = exports.flatMapConcurrently = /*#__PURE__*/(0, _Function.dual)(3, function flatMapConcurrently(fx, f, concurrency) {
-  return flatMapWithStrategy(fx, f, strategies.Bounded(concurrency));
-});
-const concatMap = exports.concatMap = /*#__PURE__*/(0, _Function.dual)(2, function concatMap(fx, f) {
-  return flatMapConcurrently(fx, f, 1);
-});
-const acquireUseRelease = exports.acquireUseRelease = /*#__PURE__*/(0, _Function.dual)(3, function acquireUseRelease(acquire, use, release) {
-  return fromSink(sink => _effect.Effect.catchAllCause(_effect.Effect.acquireUseRelease(acquire, a => (0, _run.run)(from(use(a)), sink), (a, exit) => _effect.Effect.catchAllCause(release(a, exit), sink.onFailure)), sink.onFailure));
-});
-function combine(fxs) {
-  return fromSink(sink => _effect.Effect.suspend(() => {
-    const total = fxs.length;
-    if (total === 0) return _effect.Effect.unit;
-    const values = new globalThis.Map();
-    const sample = () => Array.from({
-      length: total
-    }, (_, i) => values.get(i));
-    const emitIfReady = (value, index) => _effect.Effect.suspend(() => {
-      values.set(index, value);
-      if (values.size === total) {
-        return sink.onSuccess(sample());
-      } else {
-        return _effect.Effect.unit;
-      }
-    });
-    return _effect.Effect.all(fxs.map((fx, index) => (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => emitIfReady(a, index)))), {
-      concurrency: "unbounded"
+function mergeSwitch(fx) {
+  return mergeWithStrategy(fx, _strategies.Switch);
+}
+class MergeWithStrategy extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    switch (this.i1._tag) {
+      case "Unordered":
+        return runUnordered(this.i0, sink, this.i1.concurrency === Infinity ? "unbounded" : this.i1.concurrency);
+      case "Ordered":
+        return runOrdered(this.i0, sink, this.i1.concurrency === Infinity ? "unbounded" : this.i1.concurrency);
+      case "Switch":
+        return runSwitch(this.i0, sink);
+    }
+  }
+  static make(fx, strategy) {
+    if (fx.length === 0) return empty;else if (fx.length === 1) return fx[0];else return new MergeWithStrategy(fx.filter(Predicate.not(isEmpty)), strategy);
+  }
+}
+function runUnordered(fx, sink, concurrency) {
+  return Effect.forEach(fx, fx => fx.run(sink), {
+    concurrency,
+    discard: true
+  });
+}
+function runOrdered(fx, sink, concurrency) {
+  return Effect.suspend(() => {
+    const buffers = (0, _helpers.withBuffers)(fx.length, sink);
+    return Effect.all(fx.map((fx, i) => Effect.flatMap(fx.run(Sink.make(cause => Cause.isInterruptedOnly(cause) ? Effect.unit : sink.onFailure(cause), a => buffers.onSuccess(i, a))), () => buffers.onEnd(i))), {
+      concurrency
     });
-  }));
+  });
 }
-function struct(fxs) {
-  return map(combine(Reflect.ownKeys(fxs).map(k => map(fxs[k], a => [k, a]))), Object.fromEntries);
+function runSwitch(fx, sink) {
+  return Effect.forEach(fx, fx => fx.run(sink), {
+    concurrency: 1,
+    discard: true
+  });
 }
-function merge(fxs) {
-  return Merge.make(fxs, strategies.Unordered(Infinity));
+function takeWhile(fx, f) {
+  return TakeWhile.make(fx, f);
 }
-const mergeConcurrently = exports.mergeConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function mergeConcurrently(fxs, concurrency) {
-  return Merge.make(fxs, strategies.Unordered(concurrency));
-});
-function mergeBuffer(fxs) {
-  return Merge.make(fxs, strategies.Ordered(Infinity));
+function takeUntil(fx, f) {
+  return TakeWhile.make(fx, Predicate.not(f));
 }
-const mergeBufferConcurrently = exports.mergeBufferConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function mergeConcurrently(fxs, concurrency) {
-  return Merge.make(fxs, strategies.Ordered(concurrency));
-});
-const mergeSwitch = fxs => Merge.make(fxs, strategies.Switch);
-exports.mergeSwitch = mergeSwitch;
-function race(fxs) {
-  if (fxs.length === 0) return empty;
-  if (fxs.length === 1) return fxs[0];
-  return withScopedFork(({
-    fork,
-    sink
-  }) => _effect.Effect.asyncEffect(resume => _effect.Effect.gen(function* (_) {
-    let winningIndex = -1;
-    const fibers = yield* _(_effect.Effect.forEach(fxs, (fx, i) => fork((0, _run.run)(fx, Sink.Sink(cause => _effect.Effect.suspend(() => pickWinner(i) ? sink.onFailure(cause) : _effect.Effect.unit), a => _effect.Effect.suspend(() => pickWinner(i) ? sink.onSuccess(a) : _effect.Effect.unit))))));
-    function pickWinner(i) {
-      if (winningIndex === -1) {
-        winningIndex = i;
-        resume(_effect.Effect.succeed([i, fibers]));
-      }
-      return winningIndex === i;
+class TakeWhile extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return Sink.takeWhile(sink, this.i1, s => this.i0.run(s));
+  }
+  static make(fx, predicate) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else {
+      return new TakeWhile(fx, predicate);
     }
-  })).pipe(_effect.Effect.flatMap(([winningIndex, fibers]) => _effect.Effect.suspend(() => {
-    const [winner] = fibers.splice(winningIndex, 1);
-    return _effect.Effect.flatMap(_effect.Fiber.interruptAll(fibers), () => _effect.Fiber.join(winner));
-  }))));
-}
-const empty = exports.empty = /*#__PURE__*/new _fxPrimitive.Empty();
-const never = exports.never = /*#__PURE__*/new _fxPrimitive.Never();
-const failCause = cause => new _fxPrimitive.Fail(cause);
-exports.failCause = failCause;
-const fail = e => failCause(_effect.Cause.fail(e));
-exports.fail = fail;
-const fromSink = f => new _fxPrimitive.FromSink(sink => _effect.Effect.catchAllCause(f(sink), sink.onFailure));
-exports.fromSink = fromSink;
-const suspend = f => new _fxPrimitive.Suspend(f);
-exports.suspend = suspend;
-const sync = f => new _fxPrimitive.Sync(f);
-exports.sync = sync;
-const slice = exports.slice = /*#__PURE__*/(0, _Function.dual)(3, function slice(fx, skip, take) {
-  return Slice.make(fx, (0, _bounds.boundsFrom)(skip, take));
-});
-const take = exports.take = /*#__PURE__*/(0, _Function.dual)(2, function take(fx, n) {
-  return slice(fx, 0, n);
-});
-const drop = exports.drop = /*#__PURE__*/(0, _Function.dual)(2, function drop(fx, n) {
-  return slice(fx, n, Infinity);
-});
-const takeWhile = exports.takeWhile = /*#__PURE__*/(0, _Function.dual)(2, function takeWhile(fx, predicate) {
-  return withEarlyExit(({
-    sink
-  }) => (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => _effect.Effect.matchCauseEffect(predicate(a), {
-    onFailure: sink.onFailure,
-    onSuccess: b => b ? sink.onSuccess(a) : sink.earlyExit
-  }))));
-});
-const takeUntil = exports.takeUntil = /*#__PURE__*/(0, _Function.dual)(2, function takeUntil(fx, predicate) {
-  return takeWhile(fx, a => _effect.Effect.map(predicate(a), x => !x));
-});
-const dropWhile = exports.dropWhile = /*#__PURE__*/(0, _Function.dual)(2, function dropWhile(fx, predicate) {
-  return withEarlyExit(({
-    sink
-  }) => _effect.Effect.suspend(() => {
-    let isDropping = true;
-    return (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => isDropping ? _effect.Effect.matchCauseEffect(predicate(a), {
-      onFailure: sink.onFailure,
-      onSuccess: b => {
-        if (b) {
-          return _effect.Effect.unit;
-        } else {
-          isDropping = false;
-          return sink.onSuccess(a);
-        }
-      }
-    }) : sink.onSuccess(a)));
+  }
+}
+function dropWhile(fx, f) {
+  return DropUntil.make(fx, f);
+}
+function dropUntil(fx, f) {
+  return DropUntil.make(fx, Predicate.not(f));
+}
+class DropUntil extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return this.i0.run(Sink.dropWhile(sink, this.i1));
+  }
+  static make(fx, predicate) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else {
+      return new DropUntil(fx, predicate);
+    }
+  }
+}
+function dropAfter(fx, f) {
+  return DropAfter.make(fx, f);
+}
+class DropAfter extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return this.i0.run(Sink.dropAfter(sink, this.i1));
+  }
+  static make(fx, predicate) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else {
+      return new DropAfter(fx, predicate);
+    }
+  }
+}
+function takeWhileEffect(fx, f) {
+  return TakeWhileEffect.make(fx, f);
+}
+function takeUntilEffect(fx, f) {
+  return TakeWhileEffect.make(fx, a => Effect.map(f(a), Boolean.not));
+}
+class TakeWhileEffect extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return Sink.takeWhileEffect(sink, this.i1, s => this.i0.run(s));
+  }
+  static make(fx, f) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else {
+      return new TakeWhileEffect(fx, f);
+    }
+  }
+}
+function dropWhileEffect(fx, f) {
+  return DropWhileEffect.make(fx, f);
+}
+function dropUntilEffect(fx, f) {
+  return DropWhileEffect.make(fx, a => Effect.map(f(a), Boolean.not));
+}
+class DropWhileEffect extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return this.i0.run(Sink.dropWhileEffect(sink, this.i1));
+  }
+  static make(fx, f) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else {
+      return new DropWhileEffect(fx, f);
+    }
+  }
+}
+function dropAfterEffect(fx, f) {
+  return DropAfterEffect.make(fx, f);
+}
+class DropAfterEffect extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return this.i0.run(Sink.dropAfterEffect(sink, this.i1));
+  }
+  static make(fx, f) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else {
+      return new DropAfterEffect(fx, f);
+    }
+  }
+}
+function during(fx, window) {
+  return During.make(fx, window);
+}
+function since(fx, window) {
+  return During.make(fx, map(window, () => never));
+}
+function until(fx, window) {
+  return During.make(fx, succeed(window));
+}
+class During extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return (0, _helpers.withScopedFork)(fork => Sink.withEarlyExit(sink, s => {
+      let taking = false;
+      const onFailure = cause => s.onFailure(cause);
+      return Effect.flatMap(fork(take(this.i1, 1).run(Sink.make(onFailure, nested => {
+        taking = true;
+        return take(nested, 1).run(Sink.make(onFailure, () => s.earlyExit));
+      }))), () => Effect.zipRight(
+      // Allow fibers to start
+      (0, _helpers.adjustTime)(1), this.i0.run(Sink.make(onFailure, a => taking ? s.onSuccess(a) : Effect.unit))));
+    }), ExecutionStrategy.sequential);
+  }
+  static make(fx, window) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else {
+      return new During(fx, window);
+    }
+  }
+}
+function middleware(fx, effect, sink) {
+  return new Middleware(fx, effect, sink);
+}
+function onExit(fx, f) {
+  return middleware(fx, Effect.onExit(f));
+}
+function onInterrupt(fx, f) {
+  return middleware(fx, Effect.onInterrupt(f));
+}
+function onError(fx, f) {
+  return middleware(fx, Effect.onError(f));
+}
+const scoped = fx => middleware(fx, Effect.scoped);
+exports.scoped = scoped;
+function annotateLogs(fx, key, value) {
+  return middleware(fx, effect => Effect.annotateLogs(effect, key, value));
+}
+function annotateSpans(fx, key, value) {
+  return middleware(fx, effect => Effect.annotateSpans(effect, key, value));
+}
+const interruptible = fx => middleware(fx, Effect.interruptible);
+exports.interruptible = interruptible;
+const uninterruptible = fx => middleware(fx, Effect.uninterruptible);
+exports.uninterruptible = uninterruptible;
+function locally(use, self, value) {
+  return middleware(use, effect => Effect.locally(effect, self, value));
+}
+function locallyWith(use, self, f) {
+  return middleware(use, effect => Effect.locallyWith(effect, self, f));
+}
+function withTracerTiming(fx, enabled) {
+  return middleware(fx, effect => Effect.withTracerTiming(effect, enabled));
+}
+function withConcurrency(fx, concurrency) {
+  return middleware(fx, effect => Effect.withConcurrency(effect, concurrency));
+}
+function withConfigProvider(fx, configProvider) {
+  return middleware(fx, effect => Effect.withConfigProvider(effect, configProvider));
+}
+function withLogSpan(fx, span) {
+  return middleware(fx, effect => Effect.withLogSpan(effect, span));
+}
+function withMaxOpsBeforeYield(fx, maxOps) {
+  return middleware(fx, effect => Effect.withMaxOpsBeforeYield(effect, maxOps));
+}
+function withParentSpan(fx, parentSpan) {
+  return middleware(fx, effect => Effect.withParentSpan(effect, parentSpan));
+}
+function withRequestBatching(fx, requestBatching) {
+  return middleware(fx, effect => Effect.withRequestBatching(effect, requestBatching));
+}
+function withRequestCache(fx, cache) {
+  return middleware(fx, effect => Effect.withRequestCache(effect, cache));
+}
+function withRequestCaching(fx, requestCaching) {
+  return middleware(fx, effect => Effect.withRequestCaching(effect, requestCaching));
+}
+function withScheduler(fx, scheduler) {
+  return middleware(fx, effect => Effect.withScheduler(effect, scheduler));
+}
+function withTracer(fx, tracer) {
+  return middleware(fx, effect => Effect.withTracer(effect, tracer));
+}
+class Middleware extends _protos.FxBase {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  run(sink) {
+    return Effect.contextWithEffect(ctx => {
+      const s = Sink.provide(sink, ctx);
+      return this.i1(this.i0.run(this.i2 ? this.i2(s) : s));
+    });
+  }
+}
+function acquireUseRelease(acquire, use, release) {
+  return new AcquireUseRelease(acquire, use, release);
+}
+class AcquireUseRelease extends _protos.FxBase {
+  acquire;
+  use;
+  release;
+  constructor(acquire, use, release) {
+    super();
+    this.acquire = acquire;
+    this.use = use;
+    this.release = release;
+  }
+  run(sink) {
+    return Effect.catchAllCause(Effect.acquireUseRelease(this.acquire, a => this.use(a).run(sink), (a, exit) => Effect.catchAllCause(this.release(a, exit), cause => sink.onFailure(cause))), cause => sink.onFailure(cause));
+  }
+}
+function withSpan(self, name, options = {}) {
+  return acquireUseRelease(Effect.flatMap(Effect.optionFromOptional(Effect.currentSpan), parent => Effect.makeSpan(name, {
+    ...options,
+    parent: options?.parent || Option.getOrUndefined(parent)
+  })), span => middleware(self, effect => Effect.provideService(effect, Tracer.ParentSpan, span), s => Sink.setSpan(s, span)), (span, exit) => Effect.flatMap(Clock.currentTimeNanos, time => Effect.sync(() => span.end(time, exit))));
+}
+function provideContext(fx, context) {
+  return ProvideFx.make(fx, Provide.ProvideContext(context));
+}
+function provideLayer(fx, layer) {
+  return ProvideFx.make(fx, Provide.ProvideLayer(layer));
+}
+function provideRuntime(fx, runtime) {
+  return ProvideFx.make(fx, Provide.ProvideRuntime(runtime));
+}
+function provideService(fx, service, instance) {
+  return ProvideFx.make(fx, Provide.ProvideService(service, instance));
+}
+function provideServiceEffect(fx, service, instance) {
+  return ProvideFx.make(fx, Provide.ProvideServiceEffect(service, instance));
+}
+function provide(fx, provide) {
+  if (Layer.isLayer(provide)) return provideLayer(fx, provide);else if (Context.isContext(provide)) return provideContext(fx, provide);else return provideRuntime(fx, provide);
+}
+class ProvideFx extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return Effect.acquireUseRelease(Scope.make(), scope => Effect.matchEffect(Provide.buildWithScope(this.i1, scope), {
+      onFailure: error => sink.onFailure(Cause.fail(error)),
+      onSuccess: ctx => Effect.provide(this.i0.run(sink), ctx)
+    }), (scope, exit) => Scope.close(scope, exit));
+  }
+  static make(fx, provide) {
+    if (isEmpty(fx) || isNever(fx)) return fx;else if (isProvideFx(fx)) {
+      return new ProvideFx(fx.i0, Provide.merge(fx.i1, provide));
+    } else {
+      return new ProvideFx(fx, provide);
+    }
+  }
+}
+function isProvideFx(u) {
+  return u.constructor === ProvideFx;
+}
+function mapCause(fx, f) {
+  return new TransformerCause(fx, SyncOp.Map(f));
+}
+function mapError(fx, f) {
+  return mapCause(fx, Cause.map(f));
+}
+function filterCause(fx, f) {
+  return new TransformerCause(fx, SyncOp.Filter(f));
+}
+function filterError(fx, f) {
+  return filterCause(fx, cause => Option.match(Cause.failureOption(cause), {
+    onNone: _Function.constTrue,
+    onSome: f
   }));
-});
-const dropUntil = exports.dropUntil = /*#__PURE__*/(0, _Function.dual)(2, function dropUntil(fx, predicate) {
-  return dropWhile(fx, a => _effect.Effect.map(predicate(a), x => !x));
-});
-const dropAfter = exports.dropAfter = /*#__PURE__*/(0, _Function.dual)(2, function dropAfter(fx, predicate) {
-  return fromSink(sink => _effect.Effect.suspend(() => {
-    let isDropping = false;
-    return (0, _run.run)(fx, Sink.WithContext(sink.onFailure, a => isDropping ? _effect.Effect.unit : _effect.Effect.matchCauseEffect(predicate(a), {
-      onFailure: sink.onFailure,
-      onSuccess: b => {
-        if (b) {
-          isDropping = true;
-          return _effect.Effect.unit;
-        } else {
-          return sink.onSuccess(a);
-        }
-      }
-    })));
+}
+function filterMapCause(fx, f) {
+  return new TransformerCause(fx, SyncOp.FilterMap(f));
+}
+function filterMapError(fx, f) {
+  return filterMapCause(fx, cause => Either.match(Cause.failureOrCause(cause), {
+    onLeft: e => Option.map(f(e), Cause.fail),
+    onRight: Option.some
   }));
-});
-const continueWith = exports.continueWith = /*#__PURE__*/(0, _Function.dual)(2, function continueWith(fx, f) {
-  return fromSink(sink => _effect.Effect.flatMap((0, _run.run)(fx, sink), () => (0, _run.run)(f(), sink)));
-});
-const recoverWith = exports.recoverWith = /*#__PURE__*/(0, _Function.dual)(2, function recoverWith(fx, f) {
-  return fromSink(sink => _effect.Effect.catchAllCause(observe(fx, sink.onSuccess), cause => (0, _run.run)(from(f(cause)), sink)));
-});
-const mapEffect = exports.mapEffect = /*#__PURE__*/(0, _Function.dual)(2, function mapEffect(fx, f) {
-  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.MapEffect)(f));
-});
-const tap = exports.tap = /*#__PURE__*/(0, _Function.dual)(2, function tap(fx, f) {
-  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.TapEffect)(f));
-});
-const filterEffect = exports.filterEffect = /*#__PURE__*/(0, _Function.dual)(2, function filterEffect(fx, predicate) {
-  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.FilterEffect)(predicate));
-});
-const filterMapEffect = exports.filterMapEffect = /*#__PURE__*/(0, _Function.dual)(2, function filterEffect(fx, f) {
-  return _fxPrimitive.TransformerEffect.make(fx, (0, _effectOperator.FilterMapEffect)(f));
-});
-const middleware = exports.middleware = /*#__PURE__*/(0, _Function.dual)(args => args.length === 3 || typeof args[0] !== "function", function middleware(fx, f, g) {
-  return Middleware.make(fx, f, g ?? _Function.identity);
-});
-const loop = exports.loop = /*#__PURE__*/(0, _Function.dual)(3, function loop(fx, seed, f) {
-  return Loop.make(fx, seed, f);
-});
-const loopEffect = exports.loopEffect = /*#__PURE__*/(0, _Function.dual)(3, function loopEffect(fx, seed, f) {
-  return LoopEffect.make(fx, f, seed);
-});
-const startWith = exports.startWith = /*#__PURE__*/(0, _Function.dual)(2, function startWith(fx, value) {
-  return fromSink(sink => _effect.Effect.flatMap(sink.onSuccess(value), () => (0, _run.run)(fx, sink)));
-});
-const endWith = exports.endWith = /*#__PURE__*/(0, _Function.dual)(2, function endWith(fx, value) {
-  return fromSink(sink => _effect.Effect.flatMap((0, _run.run)(fx, sink), () => sink.onSuccess(value)));
-});
-const scan = exports.scan = /*#__PURE__*/(0, _Function.dual)(3, function loop(fx, seed, f) {
-  return continueWith(new _fxPrimitive.Succeed(seed), () => Loop.make(fx, seed, (b, a) => {
-    const b2 = f(b, a);
-    return [b2, b2];
+}
+function mapCauseEffect(fx, f) {
+  return new TransformerCause(fx, EffectOp.MapEffect(f));
+}
+function mapErrorEffect(fx, f) {
+  return mapCauseEffect(fx, cause => Either.match(Cause.failureOrCause(cause), {
+    onLeft: e => Effect.map(f(e), Cause.fail),
+    onRight: cause => Effect.succeed(cause)
   }));
-});
-const scanEffect = exports.scanEffect = /*#__PURE__*/(0, _Function.dual)(3, function loopEffect(fx, seed, f) {
-  return continueWith(new _fxPrimitive.Succeed(seed), () => LoopEffect.make(fx, (b, a) => _effect.Effect.map(f(b, a), b2 => [b2, b2]), seed));
-});
-const flatMapCauseWithStrategy = exports.flatMapCauseWithStrategy = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCause(fx, f, strategy) {
-  return new _fxPrimitive.WithFlattenStrategy(({
-    fork,
-    sink
-  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(f(cause)), sink)), sink.onSuccess)), strategy);
-});
-const flatMapErrorWithStrategy = exports.flatMapErrorWithStrategy = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCause(fx, f, strategy) {
-  return new _fxPrimitive.WithFlattenStrategy(({
-    fork,
-    sink
-  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(cause.pipe(_effect.Cause.failureOrCause, _effect.Either.match({
+}
+function filterCauseEffect(fx, f) {
+  return new TransformerCause(fx, EffectOp.FilterEffect(f));
+}
+function filterErrorEffect(fx, f) {
+  return filterCauseEffect(fx, cause => Either.match(Cause.failureOrCause(cause), {
     onLeft: f,
-    onRight: failCause
-  }))), sink)), sink.onSuccess)), strategy);
-});
-const flatMapCause = exports.flatMapCause = /*#__PURE__*/(0, _Function.dual)(2, function flatMapCause(fx, f) {
-  return flatMapCauseWithStrategy(fx, f, strategies.Unbounded);
-});
-const flatMapError = exports.flatMapError = /*#__PURE__*/(0, _Function.dual)(2, function flatMapError(fx, f) {
-  return flatMapErrorWithStrategy(fx, f, strategies.Unbounded);
-});
-const flatMapCauseConcurrently = exports.flatMapCauseConcurrently = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCauseConcurrently(fx, f, concurrency) {
-  return flatMapCauseWithStrategy(fx, f, strategies.Bounded(concurrency));
-});
-const flatMapErrorConcurrently = exports.flatMapErrorConcurrently = /*#__PURE__*/(0, _Function.dual)(3, function flatMapCauseConcurrently(fx, f, concurrency) {
-  return flatMapErrorWithStrategy(fx, f, strategies.Bounded(concurrency));
-});
-const switchMapCause = exports.switchMapCause = /*#__PURE__*/(0, _Function.dual)(2, function switchMapCause(fx, f) {
-  return flatMapCauseWithStrategy(fx, f, strategies.Switch);
-});
-const switchMapError = exports.switchMapError = /*#__PURE__*/(0, _Function.dual)(2, function switchMapError(fx, f) {
-  return flatMapErrorWithStrategy(fx, f, strategies.Switch);
-});
-const exhaustMapCause = exports.exhaustMapCause = /*#__PURE__*/(0, _Function.dual)(2, function exhaustMapCause(fx, f) {
-  return flatMapCauseWithStrategy(fx, f, strategies.Exhaust);
-});
-const exhaustMapError = exports.exhaustMapError = /*#__PURE__*/(0, _Function.dual)(2, function switchMapError(fx, f) {
-  return flatMapErrorWithStrategy(fx, f, strategies.Exhaust);
-});
-const exhaustMapLatestCause = exports.exhaustMapLatestCause = /*#__PURE__*/(0, _Function.dual)(2, function exhaustMapLatestCause(fx, f) {
-  return flatMapCauseWithStrategy(fx, f, strategies.ExhaustLatest);
-});
-const exhaustMapLatestError = exports.exhaustMapLatestError = /*#__PURE__*/(0, _Function.dual)(2, function switchMapError(fx, f) {
-  return flatMapErrorWithStrategy(fx, f, strategies.ExhaustLatest);
-});
-const matchCauseWithStrategy = exports.matchCauseWithStrategy = /*#__PURE__*/(0, _Function.dual)(2, function flatMapCause(fx, options) {
-  return new _fxPrimitive.WithFlattenStrategy(({
-    fork,
-    sink
-  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(options.onFailure(cause)), sink)), a => fork((0, _run.run)(from(options.onSuccess(a)), sink)))), options.strategy);
-});
-const matchErrorWithStrategy = exports.matchErrorWithStrategy = /*#__PURE__*/(0, _Function.dual)(2, function flatMapCause(fx, options) {
-  return new _fxPrimitive.WithFlattenStrategy(({
-    fork,
-    sink
-  }) => (0, _run.run)(fx, Sink.WithContext(cause => fork((0, _run.run)(from(cause.pipe(_effect.Cause.failureOrCause, _effect.Either.match({
-    onLeft: options.onFailure,
-    onRight: failCause
-  }))), sink)), a => fork((0, _run.run)(from(options.onSuccess(a)), sink)))), options.strategy);
-});
-const matchCause = exports.matchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Unbounded
-  });
-});
-const match = exports.match = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchErrorWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Unbounded
-  });
-});
-const matchCauseConcurrently = exports.matchCauseConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchCauseWithStrategy(fx, {
-    onFailure: options.onFailure,
-    onSuccess: options.onSuccess,
-    strategy: strategies.Bounded(options.concurrency)
-  });
-});
-const matchErrorConcurrently = exports.matchErrorConcurrently = /*#__PURE__*/(0, _Function.dual)(2, function matchErrorConcurrently(fx, options) {
-  return matchErrorWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Bounded(options.concurrency)
-  });
-});
-const switchMatchCause = exports.switchMatchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Switch
-  });
-});
-const switchMatch = exports.switchMatch = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchErrorWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Switch
-  });
-});
-const exhaustMatchCause = exports.exhaustMatchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Exhaust
-  });
-});
-const exhaustMatch = exports.exhaustMatch = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchErrorWithStrategy(fx, {
-    ...options,
-    strategy: strategies.Exhaust
-  });
-});
-const exhaustLatestMatchCause = exports.exhaustLatestMatchCause = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchCauseWithStrategy(fx, {
-    ...options,
-    strategy: strategies.ExhaustLatest
-  });
-});
-const exhaustLatestMatch = exports.exhaustLatestMatch = /*#__PURE__*/(0, _Function.dual)(2, function matchCause(fx, options) {
-  return matchErrorWithStrategy(fx, {
-    ...options,
-    strategy: strategies.ExhaustLatest
-  });
-});
-const withEarlyExit = f => new _fxPrimitive.WithEarlyExit(f);
-exports.withEarlyExit = withEarlyExit;
-const withScopedFork = f => new _fxPrimitive.WithScopedFork(f);
-exports.withScopedFork = withScopedFork;
-const withFlattenStrategy = (f, strategy) => new _fxPrimitive.WithFlattenStrategy(f, strategy);
-exports.withFlattenStrategy = withFlattenStrategy;
-const during = exports.during = /*#__PURE__*/(0, _Function.dual)(2, function during(fx, window) {
-  return withEarlyExit(({
-    fork,
-    sink
-  }) => _effect.Effect.suspend(() => {
-    let taking = false;
-    return _effect.Effect.flatMap(fork((0, _run.run)(take(window, 1), Sink.WithContext(sink.onFailure, nested => {
-      taking = true;
-      return fork((0, _run.run)(take(nested, 1), Sink.WithContext(sink.onFailure, () => sink.earlyExit)));
-    }))), () => (0, _helpers.adjustTime)(1).pipe(_effect.Effect.zipRight((0, _run.run)(fx, Sink.Sink(sink.onFailure, a => taking ? sink.onSuccess(a) : _effect.Effect.unit)))));
+    onRight: () => Effect.succeed(true)
   }));
-});
-const since = exports.since = /*#__PURE__*/(0, _Function.dual)(2, function since(fx, window) {
-  return during(fx, map(window, () => never));
-});
-const until = exports.until = /*#__PURE__*/(0, _Function.dual)(2, function until(fx, window) {
-  return during(fx, succeed(window));
-});
-const fromScheduled = exports.fromScheduled = /*#__PURE__*/(0, _Function.dual)(2, function fromScheduled(fx, scheduled) {
-  return fromSink(sink => _effect.Effect.catchAllCause(_effect.Effect.repeat(_effect.Effect.matchCauseEffect(fx, sink), scheduled), sink.onFailure));
-});
-const periodic = exports.periodic = /*#__PURE__*/(0, _Function.dual)(2, function periodic(fx, duration) {
-  return fromScheduled(fx, Schedule.spaced(duration));
-});
-const provide = exports.provide = /*#__PURE__*/(0, _Function.dual)(2, function provideContext(fx, context) {
-  if (_effect.Layer.isLayer(context)) {
-    return FxProvide.make(fx, Provide.ProvideLayer(context));
-  } else if ((0, _context.isContext)(context)) {
-    return FxProvide.make(fx, Provide.ProvideContext(context));
-  } else {
-    return FxProvide.make(fx, Provide.ProvideRuntime(context));
-  }
-});
-const provideService = exports.provideService = /*#__PURE__*/(0, _Function.dual)(3, function provideService(fx, tag, service) {
-  return FxProvide.make(fx, Provide.ProvideService(tag, service));
-});
-const provideServiceEffect = exports.provideServiceEffect = /*#__PURE__*/(0, _Function.dual)(3, function provideService(fx, tag, service) {
-  return FxProvide.make(fx, Provide.ProvideServiceEffect(tag, service));
-});
-const skipRepeatsWith = exports.skipRepeatsWith = /*#__PURE__*/(0, _Function.dual)(2, function skipRepeatsWith(fx, eq) {
-  return FilterMapLoop.make(fx, _effect.Option.none(), (previous, a) => _effect.Option.match(previous, {
-    onNone: () => _effect.Option.some([a, _effect.Option.some(a)]),
-    onSome: prev => eq(a, prev) ? _effect.Option.none() : _effect.Option.some([a, _effect.Option.some(a)])
+}
+function filterMapCauseEffect(fx, f) {
+  return new TransformerCause(fx, EffectOp.FilterMapEffect(f));
+}
+function filterMapErrorEffect(fx, f) {
+  return filterMapCauseEffect(fx, cause => Either.match(Cause.failureOrCause(cause), {
+    onLeft: e => Effect.map(f(e), Option.map(Cause.fail)),
+    onRight: cause => Effect.succeed(Option.some(cause))
   }));
-});
-const skipRepeats = fx => skipRepeatsWith(fx, _effect.Equal.equals);
-exports.skipRepeats = skipRepeats;
-class Reduce extends _effect.Effectable.Class {
-  fx;
-  seed;
-  f;
-  constructor(fx, seed, f) {
+}
+function loopCause(fx, seed, f) {
+  return new TransformerCause(fx, SyncLoopOp.LoopOperator(seed, f));
+}
+function loopError(fx, seed, f) {
+  return loopCause(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
+    onLeft: e => {
+      const [c, b2] = f(b, e);
+      return [Cause.fail(c), b2];
+    },
+    onRight: cause => [cause, b]
+  }));
+}
+function loopCauseEffect(fx, seed, f) {
+  return new TransformerCause(fx, EffectLoopOp.LoopEffectOperator(seed, f));
+}
+function loopErrorEffect(fx, seed, f) {
+  return loopCauseEffect(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
+    onLeft: e => Effect.map(f(b, e), ([c, b2]) => [Cause.fail(c), b2]),
+    onRight: cause => Effect.succeed([cause, b])
+  }));
+}
+function filterMapLoopCause(fx, seed, f) {
+  return new TransformerCause(fx, SyncLoopOp.FilterMapLoopOperator(seed, f));
+}
+function filterMapLoopError(fx, seed, f) {
+  return filterMapLoopCause(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
+    onLeft: e => {
+      const [c, b2] = f(b, e);
+      return [Option.map(Cause.fail)(c), b2];
+    },
+    onRight: cause => [Option.some(cause), b]
+  }));
+}
+function filterMapLoopCauseEffect(fx, seed, f) {
+  return new TransformerCause(fx, EffectLoopOp.FilterMapLoopEffectOperator(seed, f));
+}
+function filterMapLoopErrorEffect(fx, seed, f) {
+  return filterMapLoopCauseEffect(fx, seed, (b, cause) => Either.match(Cause.failureOrCause(cause), {
+    onLeft: e => Effect.map(f(b, e), ([c, b2]) => [Option.map(c, Cause.fail), b2]),
+    onRight: cause => Effect.succeed([Option.some(cause), b])
+  }));
+}
+class TransformerCause extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
     super();
-    this.fx = fx;
-    this.seed = seed;
-    this.f = f;
+    this.i0 = i0;
+    this.i1 = i1;
   }
-  static make(fx, seed, f) {
-    if (fx instanceof _fxPrimitive.Transformer) {
-      return FilterMapReduce.make(fx.i0, seed, (0, _syncOperator.compileSyncReducer)(fx.i1, f));
-    }
-    return new Reduce(fx, seed, f);
+  run(sink) {
+    return this.i0.run(Op.compileOperatorSinkCause(this.i1, sink));
   }
-  cached = null;
-  commit() {
-    return this.cached ||= _effect.Effect.suspend(() => {
-      let acc = this.seed;
-      return _effect.Effect.map(observe(this.fx, a => _effect.Effect.sync(() => acc = this.f(acc, a))), () => acc);
-    });
+}
+function flatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy = ExecutionStrategy.sequential) {
+  return new FlatMapCauseWithStrategy(fx, f, flattenStrategy, executionStrategy);
+}
+function flatMapErrorWithStrategy(fx, f, flattenStrategy, executionStrategy = ExecutionStrategy.sequential) {
+  return flatMapCauseWithStrategy(fx, cause => Either.match(Cause.failureOrCause(cause), {
+    onLeft: f,
+    onRight: cause => failCause(cause)
+  }), flattenStrategy, executionStrategy);
+}
+function switchMapCause(fx, f, executionStrategy) {
+  return flatMapCauseWithStrategy(fx, f, _strategies.Switch, executionStrategy);
+}
+function switchMapError(fx, f, executionStrategy) {
+  return flatMapErrorWithStrategy(fx, f, _strategies.Switch, executionStrategy);
+}
+function flatMapCause(fx, f, executionStrategy) {
+  return flatMapCauseWithStrategy(fx, f, _strategies.Unbounded, executionStrategy);
+}
+function flatMapError(fx, f, executionStrategy) {
+  return flatMapErrorWithStrategy(fx, f, _strategies.Unbounded, executionStrategy);
+}
+function flatMapCauseConcurrently(fx, f, concurrency, executionStrategy) {
+  return flatMapCauseWithStrategy(fx, f, (0, _strategies.Bounded)(concurrency), executionStrategy);
+}
+function flatMapErrorConcurrently(fx, f, concurrency, executionStrategy) {
+  return flatMapErrorWithStrategy(fx, f, (0, _strategies.Bounded)(concurrency), executionStrategy);
+}
+function exhaustMapCause(fx, f, executionStrategy) {
+  return flatMapCauseWithStrategy(fx, f, _strategies.Exhaust, executionStrategy);
+}
+function exhaustMapError(fx, f, executionStrategy) {
+  return flatMapErrorWithStrategy(fx, f, _strategies.Exhaust, executionStrategy);
+}
+function exhaustMapLatestCause(fx, f, executionStrategy) {
+  return flatMapCauseWithStrategy(fx, f, _strategies.ExhaustLatest, executionStrategy);
+}
+function exhaustMapLatestError(fx, f, executionStrategy) {
+  return flatMapErrorWithStrategy(fx, f, _strategies.ExhaustLatest, executionStrategy);
+}
+class FlatMapCauseWithStrategy extends _protos.FxBase {
+  i0;
+  i1;
+  i2;
+  i3;
+  withFork;
+  constructor(i0, i1, i2, i3) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+    this.i3 = i3;
+    this.withFork = (0, _helpers.withFlattenStrategy)(this.i2);
+  }
+  run(sink) {
+    return this.withFork(fork => this.i0.run(Sink.make(cause => fork(this.i1(cause).run(sink)), a => sink.onSuccess(a))), this.i3);
   }
 }
-class FilterMapReduce extends _effect.Effectable.Class {
+class MatchWithStrategy extends _protos.FxBase {
   i0;
   i1;
   i2;
-  constructor(i0, i1, i2) {
+  i3;
+  i4;
+  withFork;
+  constructor(i0, i1, i2, i3, i4) {
     super();
     this.i0 = i0;
     this.i1 = i1;
     this.i2 = i2;
+    this.i3 = i3;
+    this.i4 = i4;
+    this.withFork = (0, _helpers.withFlattenStrategy)(this.i3);
   }
-  static make(fx, seed, f) {
-    if (fx instanceof _fxPrimitive.FromIterable) {
-      if (Array.isArray(fx.i0)) {
-        return new _protos.OnceEffect(_effect.Effect.sync(() => reduceFilterArray(fx.i0, seed, f)));
-      } else {
-        return _effect.Effect.sync(() => reduceFilterIterable(fx.i0, seed, f));
-      }
-    }
-    return new FilterMapReduce(fx, seed, f);
+  run(sink) {
+    return this.withFork(fork => this.i0.run(Sink.make(cause => fork(this.i1(cause).run(sink)), a => fork(this.i2(a).run(sink)))), this.i4);
   }
-  cached = null;
-  commit() {
-    return this.cached ||= _effect.Effect.suspend(() => {
-      let acc = this.i1;
-      return _effect.Effect.map(observe(this.i0, a => _effect.Option.match(this.i2(acc, a), {
-        onNone: () => _effect.Effect.unit,
-        onSome: b => _effect.Effect.succeed(acc = b)
-      })), () => acc);
+}
+function matchCauseWithStrategy(fx, flattenStrategy, opts) {
+  return new MatchWithStrategy(fx, opts.onFailure, opts.onSuccess, flattenStrategy, opts.executionStrategy || ExecutionStrategy.sequential);
+}
+function matchErrorWithStrategy(fx, flattenStrategy, {
+  executionStrategy,
+  onFailure,
+  onSuccess
+}) {
+  return new MatchWithStrategy(fx, cause => Either.match(Cause.failureOrCause(cause), {
+    onLeft: onFailure,
+    onRight: cause => failCause(cause)
+  }), onSuccess, flattenStrategy, executionStrategy || ExecutionStrategy.sequential);
+}
+function matchCause(fx, opts) {
+  return matchCauseWithStrategy(fx, _strategies.Unbounded, opts);
+}
+function matchError(fx, opts) {
+  return matchErrorWithStrategy(fx, _strategies.Unbounded, opts);
+}
+function matchCauseConcurrently(fx, concurrency, opts) {
+  return matchCauseWithStrategy(fx, (0, _strategies.Bounded)(concurrency), opts);
+}
+function matchErrorConcurrently(fx, concurrency, opts) {
+  return matchErrorWithStrategy(fx, (0, _strategies.Bounded)(concurrency), opts);
+}
+function switchMatchCause(fx, opts) {
+  return matchCauseWithStrategy(fx, _strategies.Switch, opts);
+}
+function switchMatchError(fx, opts) {
+  return matchErrorWithStrategy(fx, _strategies.Switch, opts);
+}
+function exhaustMatchCause(fx, opts) {
+  return matchCauseWithStrategy(fx, _strategies.Exhaust, opts);
+}
+function exhaustMatchError(fx, opts) {
+  return matchErrorWithStrategy(fx, _strategies.Exhaust, opts);
+}
+function exhaustMatchLatestCause(fx, opts) {
+  return matchCauseWithStrategy(fx, _strategies.ExhaustLatest, opts);
+}
+function exhaustMatchLatestError(fx, opts) {
+  return matchErrorWithStrategy(fx, _strategies.ExhaustLatest, opts);
+}
+function tuple(fx) {
+  return new Tuple(fx);
+}
+class Tuple extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return (0, _helpers.tupleSink)(sink, onSuccess => Effect.forEach(this.i0, (fx, i) => fx.run(Sink.make(sink.onFailure, a => onSuccess(i, a))), UNBOUNDED), this.i0.length);
+  }
+}
+function struct(fx) {
+  const entries = Object.entries(fx);
+  return map(tuple(entries.map(([key, fx]) => map(fx, a => [key, a]))), Object.fromEntries);
+}
+function all(fx) {
+  if (Array.isArray(fx)) return tuple(fx);else return struct(fx);
+}
+function exit(fx) {
+  return new ExitFx(fx);
+}
+class ExitFx extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return this.i0.run(Sink.make(cause => sink.onSuccess(Exit.failCause(cause)), a => sink.onSuccess(Exit.succeed(a))));
+  }
+}
+function toEnqueue(fx, queue) {
+  return observe(fx, a => queue.offer(a));
+}
+function debounce(fx, delay) {
+  return switchMapEffect(fx, a => Effect.as(Effect.sleep(delay), a));
+}
+function throttle(fx, delay) {
+  return exhaustMapEffect(fx, a => Effect.as(Effect.sleep(delay), a));
+}
+function throttleLatest(fx, delay) {
+  return exhaustMapLatestEffect(fx, a => Effect.as(Effect.sleep(delay), a));
+}
+function fromAsyncIterable(iterable) {
+  return new FromAsyncIterable(iterable);
+}
+class FromAsyncIterable extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return Effect.asyncEffect(cb => {
+      const iterator = this.i0[Symbol.asyncIterator]();
+      const loop = result => result.done ? Effect.sync(() => cb(Effect.unit)) : Effect.zipRight(sink.onSuccess(result.value), Effect.flatMap(Effect.promise(() => iterator.next()), loop));
+      return Effect.flatMap(Effect.promise(() => iterator.next()), loop);
     });
   }
 }
-function reduceFilterIterable(iterable, seed, f) {
-  const iterator = iterable[Symbol.iterator]();
-  let acc = seed;
-  let result = iterator.next();
-  let option = _effect.Option.none();
-  while (!result.done) {
-    option = f(acc, result.value);
-    if (_effect.Option.isSome(option)) {
-      acc = option.value;
-    }
-    result = iterator.next();
-  }
-  return acc;
-}
-function reduceFilterArray(iterable, seed, f) {
-  const length = iterable.length;
-  let acc = seed;
-  let option = _effect.Option.none();
-  for (let i = 0; i < length; i++) {
-    option = f(acc, iterable[i]);
-    if (_effect.Option.isSome(option)) {
-      acc = option.value;
-    }
+function findFirst(fx, predicate) {
+  return Effect.asyncEffect(cb => observe(fx, a => predicate(a) ? Effect.sync(() => cb(Effect.succeed(a))) : Effect.unit));
+}
+function first(fx) {
+  return findFirst(fx, _Function.constTrue);
+}
+function either(fx) {
+  return new EitherFx(fx);
+}
+class EitherFx extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return this.i0.run(Sink.make(cause => Either.match(Cause.failureOrCause(cause), {
+      onLeft: e => sink.onSuccess(Either.left(e)),
+      onRight: cause => sink.onFailure(cause)
+    }), a => sink.onSuccess(Either.right(a))));
   }
-  return acc;
 }
-const reduce = exports.reduce = /*#__PURE__*/(0, _Function.dual)(3, function reduce(fx, seed, f) {
-  return Reduce.make(fx, seed, f);
-});
-function toChunk(fx) {
-  return reduce(fx, _effect.Chunk.empty(), _effect.Chunk.append);
+function mergeFirst(fx, that) {
+  return merge(fx, filter(that, _Function.constFalse));
 }
-const snapshot = exports.snapshot = /*#__PURE__*/(0, _Function.dual)(3, function snapshot(fx, sampled, f) {
+function mergeRace(fx, that) {
+  return new MergeRace(fx, that);
+}
+class MergeRace extends _protos.FxBase {
+  i0;
+  i1;
+  constructor(i0, i1) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+  }
+  run(sink) {
+    return Effect.gen(this, function* (_) {
+      const fiber1 = yield* _(Effect.fork(this.i0.run(Sink.make(sink.onFailure, a => Effect.flatMap(sink.onSuccess(a), () => Fiber.interrupt(fiber2))))));
+      const fiber2 = yield* _(Effect.fork(this.i1.run(sink)));
+      return yield* _(Fiber.joinAll([fiber1, fiber2]));
+    });
+  }
+}
+function raceAll(fx) {
+  return new RaceAll(fx);
+}
+function race(fx, that) {
+  return raceAll([fx, that]);
+}
+class RaceAll extends _protos.FxBase {
+  i0;
+  constructor(i0) {
+    super();
+    this.i0 = i0;
+  }
+  run(sink) {
+    return Effect.gen(this, function* (_) {
+      const winner = yield* _(Deferred.make());
+      const fibers = [];
+      for (const fx of this.i0) {
+        const fiber = yield* _(Effect.fork(fx.run(Sink.make(sink.onFailure, a => Effect.flatMap(Deferred.succeed(winner, fiber), () => sink.onSuccess(a))))));
+        fibers.push(fiber);
+      }
+      const winningFiber = yield* _(Deferred.await(winner));
+      yield* _(Fiber.interruptAll(fibers.filter(x => x !== winningFiber)));
+      return yield* _(Fiber.join(winningFiber));
+    });
+  }
+}
+function snapshot(fx, sampled, f) {
   return new Snapshot(fx, sampled, f);
-});
-function fromEmitter(f) {
-  return withEarlyExit(({
-    scope,
-    sink
-  }) => _effect.Effect.zipRight(_effect.Effect.provideService(_effect.Effect.flatMap(Emitter.make(sink), f), _effect.Scope.Scope, scope), _effect.Effect.never));
-}
-function fromEffect(effect) {
-  return (0, _effectPrimitive.matchEffectPrimitive)(effect, {
-    Success: e => succeed(e.i0),
-    Failure: e => failCause(e.i0),
-    Left: e => fail(e.left),
-    Right: e => succeed(e.right),
-    None: () => fail(new _effect.Cause.NoSuchElementException()),
-    Some: e => succeed(e.value),
-    Sync: e => sync(e.i0),
-    Otherwise: () => fromSink(sink => _effect.Effect.matchCauseEffect(effect, sink))
+}
+function sample(fx, sampled) {
+  return snapshot(fx, sampled, (_, b) => b);
+}
+class Snapshot extends _protos.FxBase {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  run(sink) {
+    return Effect.flatMap(Ref.make(Option.none()), ref => Effect.all([this.i1.run(Sink.make(sink.onFailure, b => Ref.set(ref, Option.some(b)))), this.i0.run(Sink.make(sink.onFailure, a => Effect.flatMap(Ref.get(ref), Option.match({
+      onNone: () => Effect.unit,
+      onSome: b => sink.onSuccess(this.i2(a, b))
+    }))))], UNBOUNDED));
+  }
+}
+function snapshotEffect(fx, sampled, f) {
+  return new SnapshotEffect(fx, sampled, f);
+}
+class SnapshotEffect extends _protos.FxBase {
+  i0;
+  i1;
+  i2;
+  constructor(i0, i1, i2) {
+    super();
+    this.i0 = i0;
+    this.i1 = i1;
+    this.i2 = i2;
+  }
+  run(sink) {
+    return Effect.flatMap(Ref.make(Option.none()), ref => Effect.flatMap(Effect.tap(Effect.fork(this.i1.run(Sink.make(sink.onFailure, b => Ref.set(ref, Option.some(b))))), () => this.i0.run(Sink.make(sink.onFailure, a => Effect.flatMap(Ref.get(ref), Option.match({
+      onNone: () => Effect.unit,
+      onSome: b => Effect.matchCauseEffect(this.i2(a, b), sink)
+    }))))), Fiber.interrupt));
+  }
+}
+function if_(bool, options) {
+  return switchMap(bool, b => b ? options.onTrue : options.onFalse);
+}
+function when(bool, options) {
+  return if_(bool, {
+    onTrue: succeed(options.onTrue),
+    onFalse: succeed(options.onFalse)
   });
 }
-function fromStream(stream, options) {
-  return fromSink(sink => _effect.Effect.acquireUseRelease(_effect.Scope.make(), scope => _effect.Effect.gen(function* (_) {
-    const pull = _effect.Effect.either(yield* _(_effect.Stream.toPull(stream), _effect.Effect.provideService(_effect.Scope.Scope, scope)));
-    while (true) {
-      const either = yield* _(pull);
-      if (_effect.Either.isRight(either)) {
-        yield* _(_effect.Effect.forEach(either.right, sink.onSuccess));
-      } else if (_effect.Option.isNone(either.left)) {
-        return;
-      } else {
-        yield* _(sink.onFailure(_effect.Cause.fail(either.left.value)));
-      }
-      // Schedule subsequent pulls using the current scheduler.
-      yield* _(_effect.Effect.yieldNow(options));
-    }
-  }), _effect.Scope.close));
-}
-const matchers = {
-  RefSubject: _Function.identity,
-  Fx: _Function.identity,
-  Effect: fromEffect,
-  Cause: failCause,
-  Iterable: fromIterable,
-  Otherwise: succeed
-};
-function from(input) {
-  return (0, _matchers.matchFxInput)(input, matchers);
+function mapBoth(fx, f, g) {
+  return map(mapError(fx, f), g);
 }
 //# sourceMappingURL=core.js.map