effect 2.0.0-next.41 → 2.0.0-next.43

package/STM/dist/effect-STM.cjs.prod.js

@@ -2,242 +2,1426 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-require('../../dist/Cause-384e2165.cjs.prod.js');
-require('../../dist/Chunk-6cf5a8e6.cjs.prod.js');
-require('../../dist/core-bce61cfc.cjs.prod.js');
-require('../../dist/stm-8e837f76.cjs.prod.js');
-var STM_dist_effectSTM = require('../../dist/STM-243df414.cjs.prod.js');
-require('../../dist/core-c2eb171a.cjs.prod.js');
-require('../../dist/Context-25a49952.cjs.prod.js');
-require('../../dist/Context-f958cabc.cjs.prod.js');
-require('../../dist/Equal-ce9977a8.cjs.prod.js');
-require('../../dist/Hash-1bd73210.cjs.prod.js');
-require('../../dist/Function-2e6b0cda.cjs.prod.js');
-require('../../dist/GlobalValue-cb645c99.cjs.prod.js');
-require('../../dist/Utils-864e1d48.cjs.prod.js');
-require('../../dist/Predicate-daa86e61.cjs.prod.js');
-require('../../dist/Inspectable-3c4a0f5d.cjs.prod.js');
-require('../../dist/Option-02025c86.cjs.prod.js');
-require('../../dist/Equivalence-0bc84518.cjs.prod.js');
-require('../../dist/Either-d03d5f05.cjs.prod.js');
-require('../../dist/Effectable-f867d1cb.cjs.prod.js');
-require('../../dist/Data-07dc27f1.cjs.prod.js');
-require('../../dist/Pipeable-d3ec6711.cjs.prod.js');
-require('../../dist/Number-cb2ba2e8.cjs.prod.js');
-require('../../dist/Order-8a112bfb.cjs.prod.js');
-require('../../dist/Differ-0bd34066.cjs.prod.js');
-require('../../dist/HashMap-12668911.cjs.prod.js');
-require('../../dist/HashSet-6fe62df2.cjs.prod.js');
+var Cause_dist_effectCause = require('../../Cause/dist/effect-Cause.cjs.prod.js');
+var Chunk_dist_effectChunk = require('../../Chunk/dist/effect-Chunk.cjs.prod.js');
+var core = require('../../dist/core-8ff5a82c.cjs.prod.js');
+var stm = require('../../dist/stm-fcac86d5.cjs.prod.js');
+require('../../dist/core-0b0539de.cjs.prod.js');
+require('../../Context/dist/effect-Context.cjs.prod.js');
+require('../../dist/Context-01a123ac.cjs.prod.js');
+require('../../Equal/dist/effect-Equal.cjs.prod.js');
+require('../../Hash/dist/effect-Hash.cjs.prod.js');
+require('../../Function/dist/effect-Function.cjs.prod.js');
+require('../../GlobalValue/dist/effect-GlobalValue.cjs.prod.js');
+require('../../Utils/dist/effect-Utils.cjs.prod.js');
+require('../../Predicate/dist/effect-Predicate.cjs.prod.js');
+require('../../Inspectable/dist/effect-Inspectable.cjs.prod.js');
+require('../../Option/dist/effect-Option.cjs.prod.js');
+require('../../Equivalence/dist/effect-Equivalence.cjs.prod.js');
+require('../../dist/Either-7a881c7a.cjs.prod.js');
+require('../../dist/Effectable-cd8f3a96.cjs.prod.js');
+require('../../Data/dist/effect-Data.cjs.prod.js');
+require('../../Pipeable/dist/effect-Pipeable.cjs.prod.js');
+require('../../Number/dist/effect-Number.cjs.prod.js');
+require('../../Order/dist/effect-Order.cjs.prod.js');
+require('../../Differ/dist/effect-Differ.cjs.prod.js');
+require('../../HashMap/dist/effect-HashMap.cjs.prod.js');
+require('../../dist/HashSet-6257b66d.cjs.prod.js');
 require('../../dist/Stack-fc8f9fe5.cjs.prod.js');
-require('../../dist/HashSet-c40a52b1.cjs.prod.js');
-require('../../dist/Either-3fab3796.cjs.prod.js');
-require('../../dist/FiberId-b79e8047.cjs.prod.js');
-require('../../dist/MutableRef-4a2f1f23.cjs.prod.js');
-require('../../dist/List-d9775087.cjs.prod.js');
-require('../../dist/ReadonlyArray-8157f697.cjs.prod.js');
+require('../../HashSet/dist/effect-HashSet.cjs.prod.js');
+require('../../Either/dist/effect-Either.cjs.prod.js');
+require('../../ReadonlyArray/dist/effect-ReadonlyArray.cjs.prod.js');
 require('../../dist/ReadonlyArray-f9ed7a05.cjs.prod.js');
-require('../../dist/ReadonlyRecord-8db8bada.cjs.prod.js');
-require('../../dist/RuntimeFlagsPatch-5570758d.cjs.prod.js');
-require('../../dist/Effect-4de56bb2.cjs.prod.js');
-require('../../dist/defaultServices-4112c0c9.cjs.prod.js');
-require('../../dist/Duration-0bc08d03.cjs.prod.js');
-require('../../dist/timeout-2a62e4b5.cjs.prod.js');
-require('../../dist/configProvider-2b177eac.cjs.prod.js');
-require('../../dist/config-78feb1ac.cjs.prod.js');
-require('../../dist/ConfigError-cee682fa.cjs.prod.js');
-require('../../dist/configError-6a3652f8.cjs.prod.js');
-require('../../dist/configSecret-ecb6c5b3.cjs.prod.js');
-require('../../dist/pathPatch-ded405f6.cjs.prod.js');
-require('../../dist/core-effect-bf806dd9.cjs.prod.js');
-require('../../dist/Clock-09ecce0a.cjs.prod.js');
-require('../../dist/FiberRefs-4cb171f7.cjs.prod.js');
-require('../../dist/fiberRefs-64c35250.cjs.prod.js');
-require('../../dist/patch-f27e9f08.cjs.prod.js');
-require('../../dist/label-3e143765.cjs.prod.js');
-require('../../dist/LogLevel-e9848e15.cjs.prod.js');
-require('../../dist/LogSpan-c905a192.cjs.prod.js');
-require('../../dist/Ref-30e5ee58.cjs.prod.js');
-require('../../dist/Tracer-d06d0b61.cjs.prod.js');
-require('../../dist/circular-5b3558d9.cjs.prod.js');
-require('../../dist/Exit-5691142c.cjs.prod.js');
-require('../../dist/ExecutionStrategy-dc778180.cjs.prod.js');
-require('../../dist/fiber-90ffaf8c.cjs.prod.js');
-require('../../dist/FiberStatus-b82dad24.cjs.prod.js');
-require('../../dist/fiberRuntime-1c369a47.cjs.prod.js');
-require('../../dist/Boolean-97839b78.cjs.prod.js');
-require('../../dist/Deferred-9d825b3b.cjs.prod.js');
-require('../../dist/FiberRefsPatch-cb847553.cjs.prod.js');
-require('../../dist/boundaries-5d1a46e1.cjs.prod.js');
-require('../../dist/key-330b98b1.cjs.prod.js');
-require('../../dist/keyType-8460e792.cjs.prod.js');
-require('../../dist/registry-29905dcc.cjs.prod.js');
-require('../../dist/hook-6c7550dc.cjs.prod.js');
-require('../../dist/state-0d29362f.cjs.prod.js');
-require('../../dist/pair-e5443c93.cjs.prod.js');
-require('../../dist/MutableHashMap-95493edb.cjs.prod.js');
-require('../../dist/SortedSet-424670fe.cjs.prod.js');
-require('../../dist/RedBlackTree-eb41ea8a.cjs.prod.js');
-require('../../dist/Scheduler-819ee02a.cjs.prod.js');
-require('../../dist/schedule-7e30db2d.cjs.prod.js');
-require('../../dist/Random-b4709b6a.cjs.prod.js');
-require('../../dist/ScheduleDecision-369f2d2b.cjs.prod.js');
-require('../../dist/ScheduleIntervals-db13140c.cjs.prod.js');
-require('../../dist/ScheduleInterval-78037484.cjs.prod.js');
-require('../../dist/layer-6f71c525.cjs.prod.js');
-require('../../dist/runtime-8c3f1bd3.cjs.prod.js');
-require('../../dist/Fiber-e61b3c65.cjs.prod.js');
-require('../../dist/synchronizedRef-6cfe9354.cjs.prod.js');
-require('../../dist/Scope-311c7eb9.cjs.prod.js');
-require('../../dist/circular-6a5291c3.cjs.prod.js');
-require('../../dist/Layer-b1461d01.cjs.prod.js');
-require('../../dist/query-fe4a82d6.cjs.prod.js');
-require('../../dist/cache-ab7bbfbd.cjs.prod.js');
-require('../../dist/MutableQueue-f8aba856.cjs.prod.js');
-require('../../dist/MutableList-732af09a.cjs.prod.js');
-require('../../dist/FiberRef-efb4a3ac.cjs.prod.js');
-require('../../dist/Stream-31c121b4.cjs.prod.js');
-require('../../dist/groupBy-aa608972.cjs.prod.js');
-require('../../dist/Queue-5f954287.cjs.prod.js');
-require('../../dist/queue-b81aee38.cjs.prod.js');
-require('../../dist/sink-1f4c02bb.cjs.prod.js');
-require('../../dist/Hub-6e64debd.cjs.prod.js');
-require('../../dist/childExecutorDecision-2b30946c.cjs.prod.js');
-require('../../dist/upstreamPullStrategy-34452db1.cjs.prod.js');
-require('../../dist/upstreamPullRequest-705e868d.cjs.prod.js');
-require('../../dist/mergeDecision-e483c280.cjs.prod.js');
-require('../../dist/mergeState-dba66248.cjs.prod.js');
-require('../../dist/mergeStrategy-845a1279.cjs.prod.js');
-require('../../dist/singleProducerAsyncInput-24ccc472.cjs.prod.js');
-require('../../dist/stream-71fa9ae8.cjs.prod.js');
-require('../../dist/ChannelMergeDecision-9c266aeb.cjs.prod.js');
-require('../../dist/Runtime-0d643f0c.cjs.prod.js');
-require('../../dist/Schedule-0444792d.cjs.prod.js');
-require('../../dist/StreamHaltStrategy-07f544a6.cjs.prod.js');
-require('../../dist/take-85954a45.cjs.prod.js');
-
-
-
-exports.Do = STM_dist_effectSTM.Do;
-exports.STMTypeId = STM_dist_effectSTM.STMTypeId;
-exports.acquireUseRelease = STM_dist_effectSTM.acquireUseRelease;
-exports.all = STM_dist_effectSTM.all;
-exports.as = STM_dist_effectSTM.as;
-exports.asSome = STM_dist_effectSTM.asSome;
-exports.asSomeError = STM_dist_effectSTM.asSomeError;
-exports.asUnit = STM_dist_effectSTM.asUnit;
-exports.attempt = STM_dist_effectSTM.attempt;
-exports.bind = STM_dist_effectSTM.bind;
-exports.bindTo = STM_dist_effectSTM.bindTo;
-exports.catchAll = STM_dist_effectSTM.catchAll;
-exports.catchSome = STM_dist_effectSTM.catchSome;
-exports.catchTag = STM_dist_effectSTM.catchTag;
-exports.catchTags = STM_dist_effectSTM.catchTags;
-exports.check = STM_dist_effectSTM.check;
-exports.collect = STM_dist_effectSTM.collect;
-exports.collectSTM = STM_dist_effectSTM.collectSTM;
-exports.commit = STM_dist_effectSTM.commit;
-exports.commitEither = STM_dist_effectSTM.commitEither;
-exports.cond = STM_dist_effectSTM.cond;
-exports.context = STM_dist_effectSTM.context;
-exports.contextWith = STM_dist_effectSTM.contextWith;
-exports.contextWithSTM = STM_dist_effectSTM.contextWithSTM;
-exports.die = STM_dist_effectSTM.die;
-exports.dieMessage = STM_dist_effectSTM.dieMessage;
-exports.dieSync = STM_dist_effectSTM.dieSync;
-exports.either = STM_dist_effectSTM.either;
-exports.ensuring = STM_dist_effectSTM.ensuring;
-exports.eventually = STM_dist_effectSTM.eventually;
-exports.every = STM_dist_effectSTM.every;
-exports.exists = STM_dist_effectSTM.exists;
-exports.fail = STM_dist_effectSTM.fail;
-exports.failSync = STM_dist_effectSTM.failSync;
-exports.fiberId = STM_dist_effectSTM.fiberId;
-exports.filter = STM_dist_effectSTM.filter;
-exports.filterNot = STM_dist_effectSTM.filterNot;
-exports.filterOrDie = STM_dist_effectSTM.filterOrDie;
-exports.filterOrDieMessage = STM_dist_effectSTM.filterOrDieMessage;
-exports.filterOrElse = STM_dist_effectSTM.filterOrElse;
-exports.filterOrFail = STM_dist_effectSTM.filterOrFail;
-exports.firstSuccessOf = STM_dist_effectSTM.firstSuccessOf;
-exports.flatMap = STM_dist_effectSTM.flatMap;
-exports.flatten = STM_dist_effectSTM.flatten;
-exports.flip = STM_dist_effectSTM.flip;
-exports.flipWith = STM_dist_effectSTM.flipWith;
-exports.forEach = STM_dist_effectSTM.forEach;
-exports.fromEither = STM_dist_effectSTM.fromEither;
-exports.fromOption = STM_dist_effectSTM.fromOption;
-exports.gen = STM_dist_effectSTM.gen;
-exports.head = STM_dist_effectSTM.head;
-exports["if"] = STM_dist_effectSTM.if_;
-exports.ignore = STM_dist_effectSTM.ignore;
-exports.interrupt = STM_dist_effectSTM.interrupt;
-exports.interruptAs = STM_dist_effectSTM.interruptAs;
-exports.isFailure = STM_dist_effectSTM.isFailure;
-exports.isSTM = STM_dist_effectSTM.isSTM;
-exports.isSuccess = STM_dist_effectSTM.isSuccess;
-exports.iterate = STM_dist_effectSTM.iterate;
-exports["let"] = STM_dist_effectSTM.let_;
-exports.loop = STM_dist_effectSTM.loop;
-exports.map = STM_dist_effectSTM.map;
-exports.mapAttempt = STM_dist_effectSTM.mapAttempt;
-exports.mapBoth = STM_dist_effectSTM.mapBoth;
-exports.mapError = STM_dist_effectSTM.mapError;
-exports.mapInputContext = STM_dist_effectSTM.mapInputContext;
-exports.match = STM_dist_effectSTM.match;
-exports.matchSTM = STM_dist_effectSTM.matchSTM;
-exports.merge = STM_dist_effectSTM.merge;
-exports.mergeAll = STM_dist_effectSTM.mergeAll;
-exports.negate = STM_dist_effectSTM.negate;
-exports.none = STM_dist_effectSTM.none;
-exports.option = STM_dist_effectSTM.option;
-exports.orDie = STM_dist_effectSTM.orDie;
-exports.orDieWith = STM_dist_effectSTM.orDieWith;
-exports.orElse = STM_dist_effectSTM.orElse;
-exports.orElseEither = STM_dist_effectSTM.orElseEither;
-exports.orElseFail = STM_dist_effectSTM.orElseFail;
-exports.orElseOptional = STM_dist_effectSTM.orElseOptional;
-exports.orElseSucceed = STM_dist_effectSTM.orElseSucceed;
-exports.orTry = STM_dist_effectSTM.orTry;
-exports.partition = STM_dist_effectSTM.partition;
-exports.provideContext = STM_dist_effectSTM.provideContext;
-exports.provideService = STM_dist_effectSTM.provideService;
-exports.provideServiceSTM = STM_dist_effectSTM.provideServiceSTM;
-exports.provideSomeContext = STM_dist_effectSTM.provideSomeContext;
-exports.reduce = STM_dist_effectSTM.reduce;
-exports.reduceAll = STM_dist_effectSTM.reduceAll;
-exports.reduceRight = STM_dist_effectSTM.reduceRight;
-exports.refineOrDie = STM_dist_effectSTM.refineOrDie;
-exports.refineOrDieWith = STM_dist_effectSTM.refineOrDieWith;
-exports.reject = STM_dist_effectSTM.reject;
-exports.rejectSTM = STM_dist_effectSTM.rejectSTM;
-exports.repeatUntil = STM_dist_effectSTM.repeatUntil;
-exports.repeatWhile = STM_dist_effectSTM.repeatWhile;
-exports.replicate = STM_dist_effectSTM.replicate;
-exports.replicateSTM = STM_dist_effectSTM.replicateSTM;
-exports.replicateSTMDiscard = STM_dist_effectSTM.replicateSTMDiscard;
-exports.retry = STM_dist_effectSTM.retry;
-exports.retryUntil = STM_dist_effectSTM.retryUntil;
-exports.retryWhile = STM_dist_effectSTM.retryWhile;
-exports.some = STM_dist_effectSTM.some;
-exports.succeed = STM_dist_effectSTM.succeed;
-exports.succeedNone = STM_dist_effectSTM.succeedNone;
-exports.succeedSome = STM_dist_effectSTM.succeedSome;
-exports.summarized = STM_dist_effectSTM.summarized;
-exports.suspend = STM_dist_effectSTM.suspend;
-exports.sync = STM_dist_effectSTM.sync;
-exports.tap = STM_dist_effectSTM.tap;
-exports.tapBoth = STM_dist_effectSTM.tapBoth;
-exports.tapError = STM_dist_effectSTM.tapError;
-exports["try"] = STM_dist_effectSTM.try_;
-exports.unit = STM_dist_effectSTM.unit;
-exports.unless = STM_dist_effectSTM.unless;
-exports.unlessSTM = STM_dist_effectSTM.unlessSTM;
-exports.unsome = STM_dist_effectSTM.unsome;
-exports.validateAll = STM_dist_effectSTM.validateAll;
-exports.validateFirst = STM_dist_effectSTM.validateFirst;
-exports.when = STM_dist_effectSTM.when;
-exports.whenSTM = STM_dist_effectSTM.whenSTM;
-exports.zip = STM_dist_effectSTM.zip;
-exports.zipLeft = STM_dist_effectSTM.zipLeft;
-exports.zipRight = STM_dist_effectSTM.zipRight;
-exports.zipWith = STM_dist_effectSTM.zipWith;
+require('../../ReadonlyRecord/dist/effect-ReadonlyRecord.cjs.prod.js');
+require('../../dist/FiberId-e594f6e8.cjs.prod.js');
+require('../../MutableRef/dist/effect-MutableRef.cjs.prod.js');
+require('../../List/dist/effect-List.cjs.prod.js');
+require('../../dist/RuntimeFlagsPatch-e2769b87.cjs.prod.js');
+require('../../Effect/dist/effect-Effect.cjs.prod.js');
+require('../../dist/defaultServices-086b8ac9.cjs.prod.js');
+require('../../Duration/dist/effect-Duration.cjs.prod.js');
+require('../../dist/timeout-489f3f86.cjs.prod.js');
+require('../../dist/configProvider-93617d6d.cjs.prod.js');
+require('../../dist/config-d0ddc159.cjs.prod.js');
+require('../../ConfigError/dist/effect-ConfigError.cjs.prod.js');
+require('../../dist/configError-33e55472.cjs.prod.js');
+require('../../dist/configSecret-d1caca55.cjs.prod.js');
+require('../../dist/pathPatch-15c8d723.cjs.prod.js');
+require('../../dist/core-effect-c65770cd.cjs.prod.js');
+require('../../Clock/dist/effect-Clock.cjs.prod.js');
+require('../../FiberRefs/dist/effect-FiberRefs.cjs.prod.js');
+require('../../dist/fiberRefs-be6b6a70.cjs.prod.js');
+require('../../dist/patch-c4d6c61e.cjs.prod.js');
+require('../../dist/label-655343b5.cjs.prod.js');
+require('../../LogLevel/dist/effect-LogLevel.cjs.prod.js');
+require('../../LogSpan/dist/effect-LogSpan.cjs.prod.js');
+require('../../dist/Ref-a3a4e50d.cjs.prod.js');
+require('../../Tracer/dist/effect-Tracer.cjs.prod.js');
+require('../../dist/circular-f72fcb1d.cjs.prod.js');
+require('../../Exit/dist/effect-Exit.cjs.prod.js');
+require('../../dist/ExecutionStrategy-14d3053a.cjs.prod.js');
+require('../../dist/fiber-2eb0a4c1.cjs.prod.js');
+require('../../FiberStatus/dist/effect-FiberStatus.cjs.prod.js');
+require('../../dist/fiberRuntime-af2d0ca1.cjs.prod.js');
+require('../../Boolean/dist/effect-Boolean.cjs.prod.js');
+require('../../Deferred/dist/effect-Deferred.cjs.prod.js');
+require('../../FiberRefsPatch/dist/effect-FiberRefsPatch.cjs.prod.js');
+require('../../dist/boundaries-20cfad9d.cjs.prod.js');
+require('../../dist/key-378a6a2c.cjs.prod.js');
+require('../../dist/keyType-cf67c69c.cjs.prod.js');
+require('../../dist/registry-013ecdde.cjs.prod.js');
+require('../../dist/hook-470b717e.cjs.prod.js');
+require('../../dist/state-dd1bd066.cjs.prod.js');
+require('../../dist/pair-6254cf85.cjs.prod.js');
+require('../../MutableHashMap/dist/effect-MutableHashMap.cjs.prod.js');
+require('../../SortedSet/dist/effect-SortedSet.cjs.prod.js');
+require('../../RedBlackTree/dist/effect-RedBlackTree.cjs.prod.js');
+require('../../Scheduler/dist/effect-Scheduler.cjs.prod.js');
+require('../../dist/schedule-1d92198c.cjs.prod.js');
+require('../../Random/dist/effect-Random.cjs.prod.js');
+require('../../ScheduleDecision/dist/effect-ScheduleDecision.cjs.prod.js');
+require('../../ScheduleIntervals/dist/effect-ScheduleIntervals.cjs.prod.js');
+require('../../ScheduleInterval/dist/effect-ScheduleInterval.cjs.prod.js');
+require('../../dist/layer-3b1b0e2e.cjs.prod.js');
+require('../../dist/runtime-3a59f5c4.cjs.prod.js');
+require('../../Fiber/dist/effect-Fiber.cjs.prod.js');
+require('../../dist/synchronizedRef-b4cde4de.cjs.prod.js');
+require('../../Scope/dist/effect-Scope.cjs.prod.js');
+require('../../dist/circular-c3ce70f4.cjs.prod.js');
+require('../../Layer/dist/effect-Layer.cjs.prod.js');
+require('../../dist/query-d5eefc43.cjs.prod.js');
+require('../../dist/cache-3a55a13a.cjs.prod.js');
+require('../../MutableQueue/dist/effect-MutableQueue.cjs.prod.js');
+require('../../MutableList/dist/effect-MutableList.cjs.prod.js');
+require('../../FiberRef/dist/effect-FiberRef.cjs.prod.js');
+require('../../Stream/dist/effect-Stream.cjs.prod.js');
+require('../../dist/groupBy-7ce46ea3.cjs.prod.js');
+require('../../Queue/dist/effect-Queue.cjs.prod.js');
+require('../../dist/queue-38614769.cjs.prod.js');
+require('../../dist/sink-4d668efb.cjs.prod.js');
+require('../../Hub/dist/effect-Hub.cjs.prod.js');
+require('../../dist/childExecutorDecision-b5842db5.cjs.prod.js');
+require('../../dist/upstreamPullStrategy-63cc8967.cjs.prod.js');
+require('../../dist/upstreamPullRequest-c89f818d.cjs.prod.js');
+require('../../dist/mergeDecision-07c6b5c9.cjs.prod.js');
+require('../../dist/mergeState-75990fa2.cjs.prod.js');
+require('../../dist/mergeStrategy-3dd6e55f.cjs.prod.js');
+require('../../dist/singleProducerAsyncInput-1c6cc8fb.cjs.prod.js');
+require('../../dist/stream-e670e8fa.cjs.prod.js');
+require('../../ChannelMergeDecision/dist/effect-ChannelMergeDecision.cjs.prod.js');
+require('../../Runtime/dist/effect-Runtime.cjs.prod.js');
+require('../../Schedule/dist/effect-Schedule.cjs.prod.js');
+require('../../dist/StreamHaltStrategy-b495622b.cjs.prod.js');
+require('../../dist/take-9c555b46.cjs.prod.js');
+
+/**
+ * @since 2.0.0
+ */
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+const STMTypeId = core.STMTypeId;
+
+/**
+ * @since 2.0.0
+ * @category symbols
+ */
+
+/**
+ * `STM<R, E, A>` represents an effect that can be performed transactionally,
+ *  resulting in a failure `E` or a value `A` that may require an environment
+ *  `R` to execute.
+ *
+ * Software Transactional Memory is a technique which allows composition of
+ * arbitrary atomic operations.  It is the software analog of transactions in
+ * database systems.
+ *
+ * The API is lifted directly from the Haskell package Control.Concurrent.STM
+ * although the implementation does not resemble the Haskell one at all.
+ *
+ * See http://hackage.haskell.org/package/stm-2.5.0.0/docs/Control-Concurrent-STM.html
+ *
+ * STM in Haskell was introduced in:
+ *
+ * Composable memory transactions, by Tim Harris, Simon Marlow, Simon Peyton
+ * Jones, and Maurice Herlihy, in ACM Conference on Principles and Practice of
+ * Parallel Programming 2005.
+ *
+ * See https://www.microsoft.com/en-us/research/publication/composable-memory-transactions/
+ *
+ * See also:
+ *  Lock Free Data Structures using STMs in Haskell, by Anthony Discolo, Tim
+ *  Harris, Simon Marlow, Simon Peyton Jones, Satnam Singh) FLOPS 2006: Eighth
+ *  International Symposium on Functional and Logic Programming, Fuji Susono,
+ *  JAPAN, April 2006
+ *
+ *  https://www.microsoft.com/en-us/research/publication/lock-free-data-structures-using-stms-in-haskell/
+ *
+ * The implemtation is based on the ZIO STM module, while JS environments have
+ * no race conditions from multiple threads STM provides greater benefits for
+ * synchronization of Fibers and transactional data-types can be quite useful.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * @category type lambdas
+ * @since 2.0.0
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ */
+
+/**
+ * @category models
+ * @since 2.0.0
+ */
+
+/**
+ * Returns `true` if the provided value is an `STM`, `false` otherwise.
+ *
+ * @since 2.0.0
+ * @category refinements
+ */
+const isSTM = core.isSTM;
+
+/**
+ * Treats the specified `acquire` transaction as the acquisition of a
+ * resource. The `acquire` transaction will be executed interruptibly. If it
+ * is a success and is committed the specified `release` workflow will be
+ * executed uninterruptibly as soon as the `use` workflow completes execution.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const acquireUseRelease = stm.acquireUseRelease;
+
+/**
+ * @since 2.0.0
+ * @category utils
+ */
+
+/**
+ * Runs all the provided transactional effects in sequence respecting the
+ * structure provided in input.
+ *
+ * Supports multiple arguments, a single argument tuple / array or record /
+ * struct.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const all = stm.all;
+
+/**
+ * Maps the success value of this effect to the specified constant value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const as = stm.as;
+
+/**
+ * Maps the success value of this effect to an optional value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asSome = stm.asSome;
+
+/**
+ * Maps the error value of this effect to an optional value.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asSomeError = stm.asSomeError;
+
+/**
+ * This function maps the success value of an `STM` to `void`. If the original
+ * `STM` succeeds, the returned `STM` will also succeed. If the original `STM`
+ * fails, the returned `STM` will fail with the same error.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const asUnit = stm.asUnit;
+
+/**
+ * Creates an `STM` value from a partial (but pure) function.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const attempt = stm.attempt;
+
+/**
+ * Recovers from all errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchAll = core.catchAll;
+
+/**
+ * Recovers from some or all of the error cases.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchSome = stm.catchSome;
+
+/**
+ * Recovers from the specified tagged error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTag = stm.catchTag;
+
+/**
+ * Recovers from multiple tagged errors.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const catchTags = stm.catchTags;
+
+/**
+ * Checks the condition, and if it's true, returns unit, otherwise, retries.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const check = stm.check;
+
+/**
+ * Simultaneously filters and maps the value produced by this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const collect = stm.collect;
+
+/**
+ * Simultaneously filters and maps the value produced by this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const collectSTM = stm.collectSTM;
+
+/**
+ * Commits this transaction atomically.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const commit = core.commit;
+
+/**
+ * Commits this transaction atomically, regardless of whether the transaction
+ * is a success or a failure.
+ *
+ * @since 2.0.0
+ * @category destructors
+ */
+const commitEither = stm.commitEither;
+
+/**
+ * Similar to Either.cond, evaluate the predicate, return the given A as
+ * success if predicate returns true, and the given E as error otherwise
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const cond = stm.cond;
+
+/**
+ * Retrieves the environment inside an stm.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const context = core.context;
+
+/**
+ * Accesses the environment of the transaction to perform a transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWith = core.contextWith;
+
+/**
+ * Accesses the environment of the transaction to perform a transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const contextWithSTM = core.contextWithSTM;
+
+/**
+ * Transforms the environment being provided to this effect with the specified
+ * function.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const mapInputContext = core.mapInputContext;
+
+/**
+ * Fails the transactional effect with the specified defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const die = core.die;
+
+/**
+ * Kills the fiber running the effect with a `Cause.RuntimeException` that
+ * contains the specified message.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieMessage = core.dieMessage;
+
+/**
+ * Fails the transactional effect with the specified lazily evaluated defect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const dieSync = core.dieSync;
+
+/**
+ * Converts the failure channel into an `Either`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const either = stm.either;
+
+/**
+ * Executes the specified finalization transaction whether or not this effect
+ * succeeds. Note that as with all STM transactions, if the full transaction
+ * fails, everything will be rolled back.
+ *
+ * @since 2.0.0
+ * @category finalization
+ */
+const ensuring = core.ensuring;
+
+/**
+ * Returns an effect that ignores errors and runs repeatedly until it
+ * eventually succeeds.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const eventually = stm.eventually;
+
+/**
+ * Determines whether all elements of the `Iterable<A>` satisfy the effectual
+ * predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const every = stm.every;
+
+/**
+ * Determines whether any element of the `Iterable[A]` satisfies the effectual
+ * predicate `f`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const exists = stm.exists;
+
+/**
+ * Fails the transactional effect with the specified error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fail = core.fail;
+
+/**
+ * Fails the transactional effect with the specified lazily evaluated error.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const failSync = core.failSync;
+
+/**
+ * Returns the fiber id of the fiber committing the transaction.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fiberId = stm.fiberId;
+
+/**
+ * Filters the collection using the specified effectual predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const filter = stm.filter;
+
+/**
+ * Filters the collection using the specified effectual predicate, removing
+ * all elements that satisfy the predicate.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const filterNot = stm.filterNot;
+
+/**
+ * Dies with specified defect if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrDie = stm.filterOrDie;
+
+/**
+ * Dies with a `Cause.RuntimeException` having the specified  message if the
+ * predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrDieMessage = stm.filterOrDieMessage;
+
+/**
+ * Supplies `orElse` if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrElse = stm.filterOrElse;
+
+/**
+ * Fails with the specified error if the predicate fails.
+ *
+ * @since 2.0.0
+ * @category filtering
+ */
+const filterOrFail = stm.filterOrFail;
+
+/**
+ * Feeds the value produced by this effect to the specified function, and then
+ * runs the returned effect as well to produce its results.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatMap = core.flatMap;
+
+/**
+ * Flattens out a nested `STM` effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const flatten = stm.flatten;
+
+/**
+ * Flips the success and failure channels of this transactional effect. This
+ * allows you to use all methods on the error channel, possibly before
+ * flipping back.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const flip = stm.flip;
+
+/**
+ * Swaps the error/value parameters, applies the function `f` and flips the
+ * parameters back
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const flipWith = stm.flipWith;
+
+/**
+ * Folds over the `STM` effect, handling both failure and success, but not
+ * retry.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const match = stm.match;
+
+/**
+ * Effectfully folds over the `STM` effect, handling both failure and success.
+ *
+ * @since 2.0.0
+ * @category folding
+ */
+const matchSTM = core.matchSTM;
+
+/**
+ * Applies the function `f` to each element of the `Iterable<A>` and returns
+ * a transactional effect that produces a new `Chunk<A2>`.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const forEach = stm.forEach;
+
+/**
+ * Lifts an `Either` into a `STM`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromEither = stm.fromEither;
+
+/**
+ * Lifts an `Option` into a `STM`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const fromOption = stm.fromOption;
+
+/**
+ * @since 2.0.0
+ * @category models
+ */
+
+/**
+ * @since 2.0.0
+ * @category constructors
+ */
+const gen = stm.gen;
+
+/**
+ * Returns a successful effect with the head of the list if the list is
+ * non-empty or fails with the error `None` if the list is empty.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const head = stm.head;
+const if_ = stm.if_;
+
+/**
+ * Returns a new effect that ignores the success or failure of this effect.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const ignore = stm.ignore;
+
+/**
+ * Interrupts the fiber running the effect.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interrupt = core.interrupt;
+
+/**
+ * Interrupts the fiber running the effect with the specified `FiberId`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const interruptAs = core.interruptAs;
+
+/**
+ * Returns whether this transactional effect is a failure.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isFailure = stm.isFailure;
+
+/**
+ * Returns whether this transactional effect is a success.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const isSuccess = stm.isSuccess;
+
+/**
+ * Iterates with the specified transactional function. The moral equivalent
+ * of:
+ *
+ * ```ts
+ * const s = initial
+ *
+ * while (cont(s)) {
+ *   s = body(s)
+ * }
+ *
+ * return s
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const iterate = stm.iterate;
+
+/**
+ * Loops with the specified transactional function, collecting the results
+ * into a list. The moral equivalent of:
+ *
+ * ```ts
+ * const as = []
+ * let s  = initial
+ *
+ * while (cont(s)) {
+ *   as.push(body(s))
+ *   s  = inc(s)
+ * }
+ *
+ * return as
+ * ```
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const loop = stm.loop;
+
+/**
+ * Maps the value produced by the effect.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const map = core.map;
+
+/**
+ * Maps the value produced by the effect with the specified function that may
+ * throw exceptions but is otherwise pure, translating any thrown exceptions
+ * into typed failed effects.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapAttempt = stm.mapAttempt;
+
+/**
+ * Returns an `STM` effect whose failure and success channels have been mapped
+ * by the specified pair of functions, `f` and `g`.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapBoth = stm.mapBoth;
+
+/**
+ * Maps from one error type to another.
+ *
+ * @since 2.0.0
+ * @category mapping
+ */
+const mapError = stm.mapError;
+
+/**
+ * Returns a new effect where the error channel has been merged into the
+ * success channel to their common combined type.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const merge = stm.merge;
+
+/**
+ * Merges an `Iterable<STM>` to a single `STM`, working sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const mergeAll = stm.mergeAll;
+
+/**
+ * Returns a new effect where boolean value of this effect is negated.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const negate = stm.negate;
+
+/**
+ * Requires the option produced by this value to be `None`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const none = stm.none;
+
+/**
+ * Converts the failure channel into an `Option`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const option = stm.option;
+
+/**
+ * Translates `STM` effect failure into death of the fiber, making all
+ * failures unchecked and not a part of the type of the effect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDie = stm.orDie;
+
+/**
+ * Keeps none of the errors, and terminates the fiber running the `STM` effect
+ * with them, using the specified function to convert the `E` into a defect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orDieWith = stm.orDieWith;
+
+/**
+ * Tries this effect first, and if it fails or retries, tries the other
+ * effect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElse = stm.orElse;
+
+/**
+ * Returns a transactional effect that will produce the value of this effect
+ * in left side, unless it fails or retries, in which case, it will produce
+ * the value of the specified effect in right side.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseEither = stm.orElseEither;
+
+/**
+ * Tries this effect first, and if it fails or retries, fails with the
+ * specified error.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseFail = stm.orElseFail;
+
+/**
+ * Returns an effect that will produce the value of this effect, unless it
+ * fails with the `None` value, in which case it will produce the value of the
+ * specified effect.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseOptional = stm.orElseOptional;
+
+/**
+ * Tries this effect first, and if it fails or retries, succeeds with the
+ * specified value.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orElseSucceed = stm.orElseSucceed;
+
+/**
+ * Tries this effect first, and if it enters retry, then it tries the other
+ * effect. This is an equivalent of Haskell's orElse.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const orTry = core.orTry;
+
+/**
+ * Feeds elements of type `A` to a function `f` that returns an effect.
+ * Collects all successes and failures in a tupled fashion.
+ *
+ * @since 2.0.0
+ * @category traversing
+ */
+const partition = stm.partition;
+
+/**
+ * Provides the transaction its required environment, which eliminates its
+ * dependency on `R`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideContext = stm.provideContext;
+
+/**
+ * Splits the context into two parts, providing one part using the
+ * specified layer and leaving the remainder `R0`.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideSomeContext = stm.provideSomeContext;
+
+/**
+ * Provides the effect with the single service it requires. If the transactional
+ * effect requires more than one service use `provideEnvironment` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideService = stm.provideService;
+
+/**
+ * Provides the effect with the single service it requires. If the transactional
+ * effect requires more than one service use `provideEnvironment` instead.
+ *
+ * @since 2.0.0
+ * @category context
+ */
+const provideServiceSTM = stm.provideServiceSTM;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from left to right.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduce = stm.reduce;
+
+/**
+ * Reduces an `Iterable<STM>` to a single `STM`, working sequentially.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduceAll = stm.reduceAll;
+
+/**
+ * Folds an `Iterable<A>` using an effectual function f, working sequentially
+ * from right to left.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const reduceRight = stm.reduceRight;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const refineOrDie = stm.refineOrDie;
+
+/**
+ * Keeps some of the errors, and terminates the fiber with the rest, using the
+ * specified function to convert the `E` into a `Throwable`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const refineOrDieWith = stm.refineOrDieWith;
+
+/**
+ * Fail with the returned value if the `PartialFunction` matches, otherwise
+ * continue with our held value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const reject = stm.reject;
+
+/**
+ * Continue with the returned computation if the specified partial function
+ * matches, translating the successful match into a failure, otherwise continue
+ * with our held value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const rejectSTM = stm.rejectSTM;
+
+/**
+ * Repeats this `STM` effect until its result satisfies the specified
+ * predicate.
+ *
+ * **WARNING**: `repeatUntil` uses a busy loop to repeat the effect and will
+ * consume a thread until it completes (it cannot yield). This is because STM
+ * describes a single atomic transaction which must either complete, retry or
+ * fail a transaction before yielding back to the Effect runtime.
+ *   - Use `retryUntil` instead if you don't need to maintain transaction
+ *     state for repeats.
+ *   - Ensure repeating the STM effect will eventually satisfy the predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const repeatUntil = stm.repeatUntil;
+
+/**
+ * Repeats this `STM` effect while its result satisfies the specified
+ * predicate.
+ *
+ * **WARNING**: `repeatWhile` uses a busy loop to repeat the effect and will
+ * consume a thread until it completes (it cannot yield). This is because STM
+ * describes a single atomic transaction which must either complete, retry or
+ * fail a transaction before yielding back to the Effect runtime.
+ *   - Use `retryWhile` instead if you don't need to maintain transaction
+ *     state for repeats.
+ *   - Ensure repeating the STM effect will eventually not satisfy the
+ *     predicate.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const repeatWhile = stm.repeatWhile;
+
+/**
+ * Replicates the given effect n times. If 0 or negative numbers are given, an
+ * empty `Chunk` will be returned.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicate = stm.replicate;
+
+/**
+ * Performs this transaction the specified number of times and collects the
+ * results.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicateSTM = stm.replicateSTM;
+
+/**
+ * Performs this transaction the specified number of times, discarding the
+ * results.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const replicateSTMDiscard = stm.replicateSTMDiscard;
+
+/**
+ * Abort and retry the whole transaction when any of the underlying
+ * transactional variables have changed.
+ *
+ * @since 2.0.0
+ * @category error handling
+ */
+const retry = core.retry;
+
+/**
+ * Filters the value produced by this effect, retrying the transaction until
+ * the predicate returns `true` for the value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const retryUntil = stm.retryUntil;
+
+/**
+ * Filters the value produced by this effect, retrying the transaction while
+ * the predicate returns `true` for the value.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const retryWhile = stm.retryWhile;
+
+/**
+ * Converts an option on values into an option on errors.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const some = stm.some;
+
+/**
+ * Returns an `STM` effect that succeeds with the specified value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeed = core.succeed;
+
+/**
+ * Returns an effect with the empty value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedNone = stm.succeedNone;
+
+/**
+ * Returns an effect with the optional value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const succeedSome = stm.succeedSome;
+
+/**
+ * Summarizes a `STM` effect by computing a provided value before and after
+ * execution, and then combining the values to produce a summary, together
+ * with the result of execution.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const summarized = stm.summarized;
+
+/**
+ * Suspends creation of the specified transaction lazily.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const suspend = stm.suspend;
+
+/**
+ * Returns an `STM` effect that succeeds with the specified lazily evaluated
+ * value.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const sync = core.sync;
+
+/**
+ * "Peeks" at the success of transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tap = stm.tap;
+
+/**
+ * "Peeks" at both sides of an transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapBoth = stm.tapBoth;
+
+/**
+ * "Peeks" at the error of the transactional effect.
+ *
+ * @since 2.0.0
+ * @category sequencing
+ */
+const tapError = stm.tapError;
+const try_ = stm.try_;
+
+/**
+ * The moral equivalent of `if (!p) exp`
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const unless = stm.unless;
+
+/**
+ * The moral equivalent of `if (!p) exp` when `p` has side-effects
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const unlessSTM = stm.unlessSTM;
+
+/**
+ * Converts an option on errors into an option on values.
+ *
+ * @since 2.0.0
+ * @category getters
+ */
+const unsome = stm.unsome;
+
+/**
+ * Returns an `STM` effect that succeeds with `Unit`.
+ *
+ * @since 2.0.0
+ * @category constructors
+ */
+const unit = stm.unit;
+
+/**
+ * Feeds elements of type `A` to `f` and accumulates all errors in error
+ * channel or successes in success channel.
+ *
+ * This combinator is lossy meaning that if there are errors all successes
+ * will be lost. To retain all information please use `STM.partition`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const validateAll = stm.validateAll;
+
+/**
+ * Feeds elements of type `A` to `f` until it succeeds. Returns first success
+ * or the accumulation of all errors.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const validateFirst = stm.validateFirst;
+
+/**
+ * The moral equivalent of `if (p) exp`.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const when = stm.when;
+
+/**
+ * The moral equivalent of `if (p) exp` when `p` has side-effects.
+ *
+ * @since 2.0.0
+ * @category mutations
+ */
+const whenSTM = stm.whenSTM;
+
+/**
+ * Sequentially zips this value with the specified one.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zip = core.zip;
+
+/**
+ * Sequentially zips this value with the specified one, discarding the second
+ * element of the tuple.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipLeft = core.zipLeft;
+
+/**
+ * Sequentially zips this value with the specified one, discarding the first
+ * element of the tuple.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipRight = core.zipRight;
+
+/**
+ * Sequentially zips this value with the specified one, combining the values
+ * using the specified combiner function.
+ *
+ * @since 2.0.0
+ * @category zipping
+ */
+const zipWith = core.zipWith;
+
+/**
+ * This function takes an iterable of `STM` values and returns a new
+ * `STM` value that represents the first `STM` value in the iterable
+ * that succeeds. If all of the `Effect` values in the iterable fail, then
+ * the resulting `STM` value will fail as well.
+ *
+ * This function is sequential, meaning that the `STM` values in the
+ * iterable will be executed in sequence, and the first one that succeeds
+ * will determine the outcome of the resulting `STM` value.
+ *
+ * @param effects - The iterable of `STM` values to evaluate.
+ *
+ * @returns A new `STM` value that represents the first successful
+ * `STM` value in the iterable, or a failed `STM` value if all of the
+ * `STM` values in the iterable fail.
+ *
+ * @since 2.0.0
+ * @category elements
+ */
+const firstSuccessOf = effects => suspend(() => {
+  const list = Chunk_dist_effectChunk.fromIterable(effects);
+  if (!Chunk_dist_effectChunk.isNonEmpty(list)) {
+    return dieSync(() => Cause_dist_effectCause.IllegalArgumentException(`Received an empty collection of effects`));
+  }
+  return Chunk_dist_effectChunk.reduce(Chunk_dist_effectChunk.tailNonEmpty(list), Chunk_dist_effectChunk.headNonEmpty(list), (left, right) => orElse(left, () => right));
+});
+
+/**
+ * @category do notation
+ * @since 2.0.0
+ */
+const Do = /*#__PURE__*/succeed({});
+
+/**
+ * @category do notation
+ * @since 2.0.0
+ */
+const bind = stm.bind;
+const let_ = stm.let_;
+
+/**
+ * @category do notation
+ * @since 2.0.0
+ */
+const bindTo = stm.bindTo;
+
+exports.Do = Do;
+exports.STMTypeId = STMTypeId;
+exports.acquireUseRelease = acquireUseRelease;
+exports.all = all;
+exports.as = as;
+exports.asSome = asSome;
+exports.asSomeError = asSomeError;
+exports.asUnit = asUnit;
+exports.attempt = attempt;
+exports.bind = bind;
+exports.bindTo = bindTo;
+exports.catchAll = catchAll;
+exports.catchSome = catchSome;
+exports.catchTag = catchTag;
+exports.catchTags = catchTags;
+exports.check = check;
+exports.collect = collect;
+exports.collectSTM = collectSTM;
+exports.commit = commit;
+exports.commitEither = commitEither;
+exports.cond = cond;
+exports.context = context;
+exports.contextWith = contextWith;
+exports.contextWithSTM = contextWithSTM;
+exports.die = die;
+exports.dieMessage = dieMessage;
+exports.dieSync = dieSync;
+exports.either = either;
+exports.ensuring = ensuring;
+exports.eventually = eventually;
+exports.every = every;
+exports.exists = exists;
+exports.fail = fail;
+exports.failSync = failSync;
+exports.fiberId = fiberId;
+exports.filter = filter;
+exports.filterNot = filterNot;
+exports.filterOrDie = filterOrDie;
+exports.filterOrDieMessage = filterOrDieMessage;
+exports.filterOrElse = filterOrElse;
+exports.filterOrFail = filterOrFail;
+exports.firstSuccessOf = firstSuccessOf;
+exports.flatMap = flatMap;
+exports.flatten = flatten;
+exports.flip = flip;
+exports.flipWith = flipWith;
+exports.forEach = forEach;
+exports.fromEither = fromEither;
+exports.fromOption = fromOption;
+exports.gen = gen;
+exports.head = head;
+exports["if"] = if_;
+exports.ignore = ignore;
+exports.interrupt = interrupt;
+exports.interruptAs = interruptAs;
+exports.isFailure = isFailure;
+exports.isSTM = isSTM;
+exports.isSuccess = isSuccess;
+exports.iterate = iterate;
+exports["let"] = let_;
+exports.loop = loop;
+exports.map = map;
+exports.mapAttempt = mapAttempt;
+exports.mapBoth = mapBoth;
+exports.mapError = mapError;
+exports.mapInputContext = mapInputContext;
+exports.match = match;
+exports.matchSTM = matchSTM;
+exports.merge = merge;
+exports.mergeAll = mergeAll;
+exports.negate = negate;
+exports.none = none;
+exports.option = option;
+exports.orDie = orDie;
+exports.orDieWith = orDieWith;
+exports.orElse = orElse;
+exports.orElseEither = orElseEither;
+exports.orElseFail = orElseFail;
+exports.orElseOptional = orElseOptional;
+exports.orElseSucceed = orElseSucceed;
+exports.orTry = orTry;
+exports.partition = partition;
+exports.provideContext = provideContext;
+exports.provideService = provideService;
+exports.provideServiceSTM = provideServiceSTM;
+exports.provideSomeContext = provideSomeContext;
+exports.reduce = reduce;
+exports.reduceAll = reduceAll;
+exports.reduceRight = reduceRight;
+exports.refineOrDie = refineOrDie;
+exports.refineOrDieWith = refineOrDieWith;
+exports.reject = reject;
+exports.rejectSTM = rejectSTM;
+exports.repeatUntil = repeatUntil;
+exports.repeatWhile = repeatWhile;
+exports.replicate = replicate;
+exports.replicateSTM = replicateSTM;
+exports.replicateSTMDiscard = replicateSTMDiscard;
+exports.retry = retry;
+exports.retryUntil = retryUntil;
+exports.retryWhile = retryWhile;
+exports.some = some;
+exports.succeed = succeed;
+exports.succeedNone = succeedNone;
+exports.succeedSome = succeedSome;
+exports.summarized = summarized;
+exports.suspend = suspend;
+exports.sync = sync;
+exports.tap = tap;
+exports.tapBoth = tapBoth;
+exports.tapError = tapError;
+exports["try"] = try_;
+exports.unit = unit;
+exports.unless = unless;
+exports.unlessSTM = unlessSTM;
+exports.unsome = unsome;
+exports.validateAll = validateAll;
+exports.validateFirst = validateFirst;
+exports.when = when;
+exports.whenSTM = whenSTM;
+exports.zip = zip;
+exports.zipLeft = zipLeft;
+exports.zipRight = zipRight;
+exports.zipWith = zipWith;