effect 2.0.0-next.38 → 2.0.0-next.39

package/internal/fiberScope.esm.js

@@ -0,0 +1,58 @@
+import { none } from '../FiberId/dist/effect-FiberId.esm.js';
+import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
+import { stateful } from './fiberMessage.esm.js';
+
+/** @internal */
+const FiberScopeSymbolKey = "effect/FiberScope";
+
+/** @internal */
+const FiberScopeTypeId = /*#__PURE__*/Symbol.for(FiberScopeSymbolKey);
+
+/**
+ * A `FiberScope` represents the scope of a fiber lifetime. The scope of a
+ * fiber can be retrieved using `Effect.descriptor`, and when forking fibers,
+ * you can specify a custom scope to fork them on by using the `forkIn`.
+ *
+ * @since 2.0.0
+ * @category models
+ */
+
+/** @internal */
+class Global {
+  [FiberScopeTypeId] = FiberScopeTypeId;
+  fiberId = none;
+  roots = new Set();
+  add(_runtimeFlags, child) {
+    this.roots.add(child);
+    child.addObserver(() => {
+      this.roots.delete(child);
+    });
+  }
+}
+
+/** @internal */
+class Local {
+  [FiberScopeTypeId] = FiberScopeTypeId;
+  constructor(fiberId, parent) {
+    this.fiberId = fiberId;
+    this.parent = parent;
+  }
+  add(_runtimeFlags, child) {
+    this.parent.tell(stateful(parentFiber => {
+      parentFiber.addChild(child);
+      child.addObserver(() => {
+        parentFiber.removeChild(child);
+      });
+    }));
+  }
+}
+
+/** @internal */
+const unsafeMake = fiber => {
+  return new Local(fiber.id(), fiber);
+};
+
+/** @internal */
+const globalScope = /*#__PURE__*/globalValue( /*#__PURE__*/Symbol.for("effect/FiberScope/Global"), () => new Global());
+
+export { FiberScopeTypeId, globalScope, unsafeMake };

package/internal/fiberStatus.esm.js

@@ -0,0 +1,89 @@
+import { symbol as symbol$1, equals } from '../Equal/dist/effect-Equal.esm.js';
+import { pipe } from '../Function/dist/effect-Function.esm.js';
+import { symbol, combine, hash } from '../Hash/dist/effect-Hash.esm.js';
+
+const FiberStatusSymbolKey = "effect/FiberStatus";
+
+/** @internal */
+const FiberStatusTypeId = /*#__PURE__*/Symbol.for(FiberStatusSymbolKey);
+
+/** @internal */
+const OP_DONE = "Done";
+
+/** @internal */
+
+/** @internal */
+const OP_RUNNING = "Running";
+
+/** @internal */
+
+/** @internal */
+const OP_SUSPENDED = "Suspended";
+
+/** @internal */
+
+/** @internal */
+class Done {
+  [FiberStatusTypeId] = FiberStatusTypeId;
+  _tag = OP_DONE;
+  [symbol]() {
+    return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)));
+  }
+  [symbol$1](that) {
+    return isFiberStatus(that) && that._tag === OP_DONE;
+  }
+}
+
+/** @internal */
+class Running {
+  [FiberStatusTypeId] = FiberStatusTypeId;
+  _tag = OP_RUNNING;
+  constructor(runtimeFlags) {
+    this.runtimeFlags = runtimeFlags;
+  }
+  [symbol]() {
+    return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)));
+  }
+  [symbol$1](that) {
+    return isFiberStatus(that) && that._tag === OP_RUNNING && this.runtimeFlags === that.runtimeFlags;
+  }
+}
+
+/** @internal */
+class Suspended {
+  [FiberStatusTypeId] = FiberStatusTypeId;
+  _tag = OP_SUSPENDED;
+  constructor(runtimeFlags, blockingOn) {
+    this.runtimeFlags = runtimeFlags;
+    this.blockingOn = blockingOn;
+  }
+  [symbol]() {
+    return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)), combine(hash(this.blockingOn)));
+  }
+  [symbol$1](that) {
+    return isFiberStatus(that) && that._tag === OP_SUSPENDED && this.runtimeFlags === that.runtimeFlags && equals(this.blockingOn, that.blockingOn);
+  }
+}
+
+/** @internal */
+const done = /*#__PURE__*/new Done();
+
+/** @internal */
+const running = runtimeFlags => new Running(runtimeFlags);
+
+/** @internal */
+const suspended = (runtimeFlags, blockingOn) => new Suspended(runtimeFlags, blockingOn);
+
+/** @internal */
+const isFiberStatus = u => typeof u === "object" && u != null && FiberStatusTypeId in u;
+
+/** @internal */
+const isDone = self => self._tag === OP_DONE;
+
+/** @internal */
+const isRunning = self => self._tag === OP_RUNNING;
+
+/** @internal */
+const isSuspended = self => self._tag === OP_SUSPENDED;
+
+export { FiberStatusTypeId, OP_DONE, OP_RUNNING, OP_SUSPENDED, done, isDone, isFiberStatus, isRunning, isSuspended, running, suspended };

package/{dist/groupBy-d11b31b1.esm.js → internal/groupBy.esm.js}

@@ -1,16 +1,18 @@
-import { e as isInterruptedOnly } from './Cause-5946c7a3.esm.js';
-import { s as map$2, o as of, l as unsafeFromArray } from './Chunk-4c1f4599.esm.js';
-import { m as make$1, _ as _await, s as succeed$1 } from './Deferred-9010d2ac.esm.js';
-import { w as succeed, b as as, M as gen, N as acquireRelease, k as flatMap$1, j as zipRight, r as map$1, A as forkScoped, s as sync, v as forEach, a3 as catchSomeCause, e as unit } from './Effect-ee05a487.esm.js';
-import { s as succeed$2, h as map$4 } from './Exit-666b4f01.esm.js';
-import { d as dual, p as pipe } from './Function-12511160.esm.js';
-import { b as match, e as fromNullable, m as map$3, s as some, n as none } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
-import { s as shutdown, b as bounded, o as offer, D as DequeueTypeId, d as capacity, a as size, e as awaitShutdown, i as isShutdown, f as isFull, g as isEmpty, t as take, h as takeAll, j as takeUpTo, k as takeBetween, l as takeN, p as poll, u as unbounded } from './Queue-d99be5de.esm.js';
-import { m as make$2, u as update, g as get } from './Ref-5eefaff1.esm.js';
-import { p as pipeTo, d as drain, r as runScoped, a as readWithCause, f as flatMap$2, b as fromEffect$1 } from './sink-637a9670.esm.js';
-import { ak as flatMap, aq as flattenTake, aG as fromQueue, ac as filterEffect, a_ as map, dA as zipWithIndex, d9 as unwrapScoped, dH as mapEffectSequential, dI as distributedWithDynamicCallback, ao as flattenExitOption, dJ as matchConcurrency, az as fromEffect, dK as mapEffectPar, au as toChannel } from './stream-e44fba40.esm.js';
-import { T as TakeImpl, o as of$1, c as chunk, f as failCause, e as end } from './take-0d5e0eab.esm.js';
+import { isInterruptedOnly } from '../Cause/dist/effect-Cause.esm.js';
+import { map as map$2, of, unsafeFromArray } from '../Chunk/dist/effect-Chunk.esm.js';
+import { make as make$1, await as _await, succeed as succeed$1 } from '../Deferred/dist/effect-Deferred.esm.js';
+import { succeed, as, gen, acquireRelease, flatMap as flatMap$1, zipRight, map as map$1, forkScoped, sync, forEach, catchSomeCause, unit } from '../Effect/dist/effect-Effect.esm.js';
+import { succeed as succeed$2, map as map$4 } from '../Exit/dist/effect-Exit.esm.js';
+import { dual, pipe } from '../Function/dist/effect-Function.esm.js';
+import { match, fromNullable, map as map$3, some, none } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { shutdown, bounded, offer, DequeueTypeId, capacity, size, awaitShutdown, isShutdown, isFull, isEmpty, take, takeAll, takeUpTo, takeBetween, takeN, poll, unbounded } from '../Queue/dist/effect-Queue.esm.js';
+import { make as make$2, update, get } from '../Ref/dist/effect-Ref.esm.js';
+import { drain } from './channel.esm.js';
+import { runScoped } from './channel/channelExecutor.esm.js';
+import { pipeTo, readWithCause, flatMap as flatMap$2, fromEffect as fromEffect$1 } from './core-stream.esm.js';
+import { flatMap, flattenTake, fromQueue, filterEffect, map, zipWithIndex, unwrapScoped, mapEffectSequential, distributedWithDynamicCallback, flattenExitOption, matchConcurrency, fromEffect, mapEffectPar, toChannel } from './stream.esm.js';
+import { TakeImpl, of as of$1, chunk, failCause, end } from './take.esm.js';
 
 /** @internal */
 const GroupBySymbolKey = "effect/GroupBy";
@@ -203,4 +205,4 @@ const groupByIterable = /*#__PURE__*/dual(2, (iterable, f) => {
   return unsafeFromArray(builder.map(tuple => [tuple[0], unsafeFromArray(tuple[1])]));
 });
 
-export { GroupByTypeId as G, groupByKey as a, bindEffect as b, first as c, make as d, evaluate as e, filter as f, groupBy as g, mapEffectOptions as m };
+export { GroupByTypeId, bindEffect, evaluate, filter, first, groupBy, groupByIterable, groupByKey, make, mapEffectOptions };

package/{dist/Hub-121dbf51.esm.js → internal/hub.esm.js}

@@ -1,13 +1,14 @@
-import { f as fromIterable, u as unsafeGet, d as drop, e as empty, i as isEmpty$2, a as unsafeHead, o as of, b as appendAll, c as append, g as filter, p as prepend } from './Chunk-4c1f4599.esm.js';
-import { p as pipe, d as dual } from './Function-12511160.esm.js';
-import { f as flatMap, s as sync, m as map, d as deferredMake, I as InvalidHubCapacityException, a as suspend, i as interrupt, b as deferredAwait, u as uninterruptible, w as withFiberRuntime, c as asUnit, e as whenEffect, g as deferredSucceed, z as zipRight, h as exitInterrupt, j as succeed, t as tap, k as deferredInterruptWith, l as deferredUnsafeMake, o as onInterrupt, n as fiberId, p as unit, q as deferredUnsafeDone } from './core-64ab7ff5.esm.js';
-import { s as sequential } from './ExecutionStrategy-e3775e86.esm.js';
-import { s as scopeMake, a as all, b as acquireRelease, f as forEachParUnbounded, c as forEachParUnboundedDiscard } from './fiberRuntime-bfcf5f49.esm.js';
-import { E as EnqueueTypeId, e as enqueueVariance, D as DequeueTypeId, d as dequeueVariance } from './queue-f74db567.esm.js';
-import { u as unbounded$2, i as isEmpty$3, E as EmptyMutableQueue, o as offer, p as pollUpTo, a as poll, b as offerAll } from './MutableQueue-446ac662.esm.js';
-import { m as make, g as get, s as set } from './MutableRef-2734b082.esm.js';
-import { n as none, s as some } from './Option-df40d2b9.esm.js';
-import { p as pipeArguments } from './Pipeable-10760a1d.esm.js';
+import { fromIterable, unsafeGet, drop, empty, isEmpty as isEmpty$1, unsafeHead, of, prepend, filter, appendAll, append } from '../Chunk/dist/effect-Chunk.esm.js';
+import { pipe, dual } from '../Function/dist/effect-Function.esm.js';
+import { InvalidHubCapacityException } from './cause.esm.js';
+import { flatMap, sync, map, deferredMake, fiberId, withFiberRuntime, unit, succeed, suspend, interrupt, deferredAwait, uninterruptible, asUnit, whenEffect, deferredSucceed, zipRight, exitInterrupt, tap, deferredUnsafeDone, deferredInterruptWith, deferredUnsafeMake, onInterrupt } from './core.esm.js';
+import { sequential } from './executionStrategy.esm.js';
+import { scopeMake, forEachParUnboundedDiscard, all, acquireRelease, forEachParUnbounded } from './fiberRuntime.esm.js';
+import { EnqueueTypeId, enqueueVariance, DequeueTypeId, dequeueVariance } from './queue.esm.js';
+import { unbounded as unbounded$1, poll, EmptyMutableQueue, offer, isEmpty as isEmpty$2, offerAll, pollUpTo } from '../MutableQueue/dist/effect-MutableQueue.esm.js';
+import { make, get, set } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { none, some } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
 
 /** @internal */
 
@@ -34,46 +35,46 @@ const removeSubscribers = (subscription, pollers) => subscribers => {
 };
 
 /** @internal */
-const bounded$1 = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new BackPressureStrategy())));
+const bounded = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new BackPressureStrategy())));
 
 /** @internal */
-const dropping$1 = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
+const dropping = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
 
 /** @internal */
-const sliding$1 = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new SlidingStrategy())));
+const sliding = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new SlidingStrategy())));
 
 /** @internal */
-const unbounded$1 = () => pipe(sync(() => makeUnboundedHub()), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
+const unbounded = () => pipe(sync(() => makeUnboundedHub()), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
 
 /** @internal */
-const capacity$1 = self => self.capacity();
+const capacity = self => self.capacity();
 
 /** @internal */
-const size$1 = self => self.size();
+const size = self => self.size();
 
 /** @internal */
-const isFull$1 = self => self.isFull();
+const isFull = self => self.isFull();
 
 /** @internal */
-const isEmpty$1 = self => self.isEmpty();
+const isEmpty = self => self.isEmpty();
 
 /** @internal */
-const shutdown$1 = self => self.shutdown();
+const shutdown = self => self.shutdown();
 
 /** @internal */
-const isShutdown$1 = self => self.isShutdown();
+const isShutdown = self => self.isShutdown();
 
 /** @internal */
-const awaitShutdown$1 = self => self.awaitShutdown();
+const awaitShutdown = self => self.awaitShutdown();
 
 /** @internal */
-const publish$1 = /*#__PURE__*/dual(2, (self, value) => self.publish(value));
+const publish = /*#__PURE__*/dual(2, (self, value) => self.publish(value));
 
 /** @internal */
-const publishAll$1 = /*#__PURE__*/dual(2, (self, elements) => self.publishAll(elements));
+const publishAll = /*#__PURE__*/dual(2, (self, elements) => self.publishAll(elements));
 
 /** @internal */
-const subscribe$1 = self => self.subscribe();
+const subscribe = self => self.subscribe();
 
 /** @internal */
 const makeBoundedHub = requestedCapacity => {
@@ -93,7 +94,7 @@ const makeUnboundedHub = () => {
 };
 
 /** @internal */
-const makeSubscription = (hub, subscribers, strategy) => map(deferredMake(), deferred => unsafeMakeSubscription(hub, subscribers, hub.subscribe(), unbounded$2(), deferred, make(false), strategy));
+const makeSubscription = (hub, subscribers, strategy) => map(deferredMake(), deferred => unsafeMakeSubscription(hub, subscribers, hub.subscribe(), unbounded$1(), deferred, make(false), strategy));
 
 /** @internal */
 const unsafeMakeSubscription = (hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => {
@@ -423,7 +424,7 @@ class BoundedHubSingle {
   }
   publishAll(elements) {
     const chunk = fromIterable(elements);
-    if (isEmpty$2(chunk)) {
+    if (isEmpty$1(chunk)) {
       return chunk;
     }
     if (this.publish(unsafeHead(chunk))) {
@@ -703,7 +704,7 @@ class SubscriptionImpl {
       if (get(this.shutdownFlag)) {
         return interrupt;
       }
-      const message = isEmpty$3(this.pollers) ? this.subscription.poll(EmptyMutableQueue) : EmptyMutableQueue;
+      const message = isEmpty$2(this.pollers) ? this.subscription.poll(EmptyMutableQueue) : EmptyMutableQueue;
       if (message === EmptyMutableQueue) {
         const deferred = deferredUnsafeMake(state.id());
         return pipe(suspend(() => {
@@ -723,7 +724,7 @@ class SubscriptionImpl {
       if (get(this.shutdownFlag)) {
         return interrupt;
       }
-      const as = isEmpty$3(this.pollers) ? unsafePollAllSubscription(this.subscription) : empty();
+      const as = isEmpty$2(this.pollers) ? unsafePollAllSubscription(this.subscription) : empty();
       this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
       return succeed(as);
     });
@@ -733,7 +734,7 @@ class SubscriptionImpl {
       if (get(this.shutdownFlag)) {
         return interrupt;
       }
-      const as = isEmpty$3(this.pollers) ? unsafePollN(this.subscription, max) : empty();
+      const as = isEmpty$2(this.pollers) ? unsafePollN(this.subscription, max) : empty();
       this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
       return succeed(as);
     });
@@ -833,7 +834,7 @@ class HubImpl {
       }
       const surplus = unsafePublishAll(this.hub, elements);
       this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
-      if (isEmpty$2(surplus)) {
+      if (isEmpty$1(surplus)) {
         return succeed(true);
       }
       return this.strategy.handleSurplus(this.hub, this.subscribers, surplus, this.shutdownFlag);
@@ -930,7 +931,7 @@ const unsafeRemove = (queue, value) => {
  * @internal
  */
 class BackPressureStrategy {
-  publishers = unbounded$2();
+  publishers = unbounded$1();
   shutdown() {
     return flatMap(fiberId, fiberId => flatMap(sync(() => unsafePollAllQueue(this.publishers)), publishers => forEachParUnboundedDiscard(publishers, ([_, deferred, last]) => last ? pipe(deferredInterruptWith(deferred, fiberId), asUnit) : unit, false)));
   }
@@ -1072,7 +1073,7 @@ const unsafeStrategyCompletePollers = (strategy, hub, subscribers, subscription,
     const poller = pipe(pollers, poll(EmptyMutableQueue));
     if (poller === EmptyMutableQueue) {
       pipe(subscribers, removeSubscribers(subscription, pollers));
-      if (isEmpty$3(pollers)) {
+      if (isEmpty$2(pollers)) {
         keepPolling = false;
       } else {
         pipe(subscribers, addSubscribers(subscription, pollers));
@@ -1098,167 +1099,4 @@ const unsafeStrategyCompleteSubscribers = (strategy, hub, subscribers) => {
   }
 };
 
-/**
- * @since 2.0.0
- */
-
-/**
- * A `Hub<A>` is an asynchronous message hub into which publishers can publish
- * messages of type `A` and subscribers can subscribe to take messages of type
- * `A`.
- *
- * @since 2.0.0
- * @category models
- */
-
-/**
- * Creates a bounded hub with the back pressure strategy. The hub will retain
- * messages until they have been taken by all subscribers, applying back
- * pressure to publishers if the hub is at capacity.
- *
- * For best performance use capacities that are powers of two.
- *
- * @since 2.0.0
- * @category constructors
- */
-const bounded = bounded$1;
-
-/**
- * Creates a bounded hub with the dropping strategy. The hub will drop new
- * messages if the hub is at capacity.
- *
- * For best performance use capacities that are powers of two.
- *
- * @since 2.0.0
- * @category constructors
- */
-const dropping = dropping$1;
-
-/**
- * Creates a bounded hub with the sliding strategy. The hub will add new
- * messages and drop old messages if the hub is at capacity.
- *
- * For best performance use capacities that are powers of two.
- *
- * @since 2.0.0
- * @category constructors
- */
-const sliding = sliding$1;
-
-/**
- * Creates an unbounded hub.
- *
- * @since 2.0.0
- * @category constructors
- */
-const unbounded = unbounded$1;
-
-/**
- *  Returns the number of elements the queue can hold.
- *
- * @since 2.0.0
- * @category getters
- */
-const capacity = capacity$1;
-
-/**
- * Retrieves the size of the queue, which is equal to the number of elements
- * in the queue. This may be negative if fibers are suspended waiting for
- * elements to be added to the queue.
- *
- * @since 2.0.0
- * @category getters
- */
-const size = size$1;
-
-/**
- * Returns `true` if the `Queue` contains at least one element, `false`
- * otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isFull = isFull$1;
-
-/**
- * Returns `true` if the `Queue` contains zero elements, `false` otherwise.
- *
- * @since 2.0.0
- * @category getters
- */
-const isEmpty = isEmpty$1;
-
-/**
- * Interrupts any fibers that are suspended on `offer` or `take`. Future calls
- * to `offer*` and `take*` will be interrupted immediately.
- *
- * @since 2.0.0
- * @category utils
- */
-const shutdown = shutdown$1;
-
-/**
- * Returns `true` if `shutdown` has been called, otherwise returns `false`.
- *
- * @since 2.0.0
- * @category getters
- */
-const isShutdown = isShutdown$1;
-
-/**
- * Waits until the queue is shutdown. The `Effect` returned by this method will
- * not resume until the queue has been shutdown. If the queue is already
- * shutdown, the `Effect` will resume right away.
- *
- * @since 2.0.0
- * @category utils
- */
-const awaitShutdown = awaitShutdown$1;
-
-/**
- * Publishes a message to the hub, returning whether the message was published
- * to the hub.
- *
- * @since 2.0.0
- * @category utils
- */
-const publish = publish$1;
-
-/**
- * Publishes all of the specified messages to the hub, returning whether they
- * were published to the hub.
- *
- * @since 2.0.0
- * @category utils
- */
-const publishAll = publishAll$1;
-
-/**
- * Subscribes to receive messages from the hub. The resulting subscription can
- * be evaluated multiple times within the scope to take a message from the hub
- * each time.
- *
- * @since 2.0.0
- * @category utils
- */
-const subscribe = subscribe$1;
-
-var Hub = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  bounded: bounded,
-  dropping: dropping,
-  sliding: sliding,
-  unbounded: unbounded,
-  capacity: capacity,
-  size: size,
-  isFull: isFull,
-  isEmpty: isEmpty,
-  shutdown: shutdown,
-  isShutdown: isShutdown,
-  awaitShutdown: awaitShutdown,
-  publish: publish,
-  publishAll: publishAll,
-  subscribe: subscribe
-});
-
-export { Hub as H, shutdown as a, bounded as b, sliding as c, dropping as d, capacity as e, size as f, isEmpty as g, isShutdown as h, isFull as i, awaitShutdown as j, publishAll as k, publish as p, subscribe as s, unbounded as u };
+export { DroppingStrategy, SlidingStrategy, awaitShutdown, bounded, capacity, dropping, isEmpty, isFull, isShutdown, makeHub, publish, publishAll, shutdown, size, sliding, subscribe, unbounded, unsafeMakeHub, unsafeMakeSubscription };

package/internal/keyedPool.esm.js

@@ -0,0 +1,161 @@
+import { decode, infinity } from '../Duration/dist/effect-Duration.esm.js';
+import { equals, symbol as symbol$1 } from '../Equal/dist/effect-Equal.esm.js';
+import { dual, pipe } from '../Function/dist/effect-Function.esm.js';
+import { symbol, combine, hash, string } from '../Hash/dist/effect-Hash.esm.js';
+import { empty, get as get$2, has, set, remove, values } from '../HashMap/dist/effect-HashMap.esm.js';
+import { map, context, fiberId, sync, flatMap, forEachSequentialDiscard, suspend, uninterruptibleMask, deferredUnsafeMake, provideContext, matchCauseEffect, zipRight, deferredFailCause, failCause, as, deferredSucceed, deferredAwait, succeed, forEachSequential } from './core.esm.js';
+import { all, scopeMake, scopeExtend } from './fiberRuntime.esm.js';
+import { get as get$1, makeWithTTL as makeWithTTL$1 } from './pool.esm.js';
+import { make as make$1, get as get$3, update } from '../MutableRef/dist/effect-MutableRef.esm.js';
+import { getOrUndefined, getOrElse, none, some } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { isTagged } from '../Predicate/dist/effect-Predicate.esm.js';
+
+/** @internal */
+const KeyedPoolSymbolKey = "effect/KeyedPool";
+
+/** @internal */
+const KeyedPoolTypeId = /*#__PURE__*/Symbol.for(KeyedPoolSymbolKey);
+const KeyedPoolMapValueSymbol = /*#__PURE__*/Symbol.for("effect/KeyedPool/MapValue");
+const keyedPoolVariance = {
+  _K: _ => _,
+  _E: _ => _,
+  _A: _ => _
+};
+class KeyedPoolImpl {
+  [KeyedPoolTypeId] = keyedPoolVariance;
+  constructor(getOrCreatePool, activePools) {
+    this.getOrCreatePool = getOrCreatePool;
+    this.activePools = activePools;
+  }
+  get(key) {
+    return flatMap(this.getOrCreatePool(key), get$1);
+  }
+  invalidate(item) {
+    return flatMap(this.activePools(), forEachSequentialDiscard(pool => pool.invalidate(item)));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+class Complete {
+  _tag = "Complete";
+  [KeyedPoolMapValueSymbol] = KeyedPoolMapValueSymbol;
+  constructor(pool) {
+    this.pool = pool;
+  }
+  [symbol]() {
+    return pipe(string("effect/KeyedPool/Complete"), combine(hash(this.pool)));
+  }
+  [symbol$1](u) {
+    return isComplete(u) && equals(this.pool, u.pool);
+  }
+}
+const isComplete = u => isTagged(u, "Complete") && KeyedPoolMapValueSymbol in u;
+class Pending {
+  _tag = "Pending";
+  [KeyedPoolMapValueSymbol] = KeyedPoolMapValueSymbol;
+  constructor(deferred) {
+    this.deferred = deferred;
+  }
+  [symbol]() {
+    return pipe(string("effect/KeyedPool/Pending"), combine(hash(this.deferred)));
+  }
+  [symbol$1](u) {
+    return isPending(u) && equals(this.deferred, u.deferred);
+  }
+}
+const isPending = u => isTagged(u, "Pending") && KeyedPoolMapValueSymbol in u;
+const makeImpl = (get, min, max, timeToLive) => pipe(all([context(), fiberId, sync(() => make$1(empty())), scopeMake()]), map(([context, fiberId, map, scope]) => {
+  const getOrCreatePool = key => suspend(() => {
+    let value = getOrUndefined(get$2(get$3(map), key));
+    if (value === undefined) {
+      return uninterruptibleMask(restore => {
+        const deferred = deferredUnsafeMake(fiberId);
+        value = new Pending(deferred);
+        let previous = undefined;
+        if (has(get$3(map), key)) {
+          previous = getOrUndefined(get$2(get$3(map), key));
+        } else {
+          update(map, set(key, value));
+        }
+        if (previous === undefined) {
+          return pipe(restore(scopeExtend(makeWithTTL$1({
+            acquire: provideContext(get(key), context),
+            min: min(key),
+            max: max(key),
+            timeToLive: getOrElse(timeToLive(key), () => infinity)
+          }), scope)), matchCauseEffect({
+            onFailure: cause => {
+              const current = getOrUndefined(get$2(get$3(map), key));
+              if (equals(current, value)) {
+                update(map, remove(key));
+              }
+              return zipRight(deferredFailCause(deferred, cause), failCause(cause));
+            },
+            onSuccess: pool => {
+              update(map, set(key, new Complete(pool)));
+              return as(deferredSucceed(deferred, pool), pool);
+            }
+          }));
+        }
+        switch (previous._tag) {
+          case "Complete":
+            {
+              return succeed(previous.pool);
+            }
+          case "Pending":
+            {
+              return restore(deferredAwait(previous.deferred));
+            }
+        }
+      });
+    }
+    switch (value._tag) {
+      case "Complete":
+        {
+          return succeed(value.pool);
+        }
+      case "Pending":
+        {
+          return deferredAwait(value.deferred);
+        }
+    }
+  });
+  const activePools = () => suspend(() => forEachSequential(Array.from(values(get$3(map))), value => {
+    switch (value._tag) {
+      case "Complete":
+        {
+          return succeed(value.pool);
+        }
+      case "Pending":
+        {
+          return deferredAwait(value.deferred);
+        }
+    }
+  }));
+  return new KeyedPoolImpl(getOrCreatePool, activePools);
+}));
+
+/** @internal */
+const make = options => makeImpl(options.acquire, () => options.size, () => options.size, () => none());
+
+/** @internal */
+const makeWith = options => makeImpl(options.acquire, options.size, options.size, () => none());
+
+/** @internal */
+const makeWithTTL = options => {
+  const timeToLive = decode(options.timeToLive);
+  return makeImpl(options.acquire, options.min, options.max, () => some(timeToLive));
+};
+
+/** @internal */
+const makeWithTTLBy = options => makeImpl(options.acquire, options.min, options.max, key => some(decode(options.timeToLive(key))));
+
+/** @internal */
+const get = /*#__PURE__*/dual(2, (self, key) => self.get(key));
+
+/** @internal */
+const invalidate = /*#__PURE__*/dual(2, (self, item) => self.invalidate(item));
+
+export { KeyedPoolTypeId, get, invalidate, make, makeWith, makeWithTTL, makeWithTTLBy };