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

package/internal/{hub.esm.js → pubsub.esm.js}

@@ -1,14 +1,14 @@
 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';
+import { InvalidPubSubCapacityException } 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';
 
 /** @internal */
 
@@ -35,16 +35,16 @@ const removeSubscribers = (subscription, pollers) => subscribers => {
 };
 
 /** @internal */
-const bounded = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new BackPressureStrategy())));
+const bounded = requestedCapacity => pipe(sync(() => makeBoundedPubSub(requestedCapacity)), flatMap(atomicPubSub => makePubSub(atomicPubSub, new BackPressureStrategy())));
 
 /** @internal */
-const dropping = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
+const dropping = requestedCapacity => pipe(sync(() => makeBoundedPubSub(requestedCapacity)), flatMap(atomicPubSub => makePubSub(atomicPubSub, new DroppingStrategy())));
 
 /** @internal */
-const sliding = requestedCapacity => pipe(sync(() => makeBoundedHub(requestedCapacity)), flatMap(atomicHub => makeHub(atomicHub, new SlidingStrategy())));
+const sliding = requestedCapacity => pipe(sync(() => makeBoundedPubSub(requestedCapacity)), flatMap(atomicPubSub => makePubSub(atomicPubSub, new SlidingStrategy())));
 
 /** @internal */
-const unbounded = () => pipe(sync(() => makeUnboundedHub()), flatMap(atomicHub => makeHub(atomicHub, new DroppingStrategy())));
+const unbounded = () => pipe(sync(() => makeUnboundedPubSub()), flatMap(atomicPubSub => makePubSub(atomicPubSub, new DroppingStrategy())));
 
 /** @internal */
 const capacity = self => self.capacity();
@@ -77,32 +77,32 @@ const publishAll = /*#__PURE__*/dual(2, (self, elements) => self.publishAll(elem
 const subscribe = self => self.subscribe();
 
 /** @internal */
-const makeBoundedHub = requestedCapacity => {
+const makeBoundedPubSub = requestedCapacity => {
   ensureCapacity(requestedCapacity);
   if (requestedCapacity === 1) {
-    return new BoundedHubSingle();
+    return new BoundedPubSubSingle();
   } else if (nextPow2(requestedCapacity) === requestedCapacity) {
-    return new BoundedHubPow2(requestedCapacity);
+    return new BoundedPubSubPow2(requestedCapacity);
   } else {
-    return new BoundedHubArb(requestedCapacity);
+    return new BoundedPubSubArb(requestedCapacity);
   }
 };
 
 /** @internal */
-const makeUnboundedHub = () => {
-  return new UnboundedHub();
+const makeUnboundedPubSub = () => {
+  return new UnboundedPubSub();
 };
 
 /** @internal */
-const makeSubscription = (hub, subscribers, strategy) => map(deferredMake(), deferred => unsafeMakeSubscription(hub, subscribers, hub.subscribe(), unbounded$1(), deferred, make(false), strategy));
+const makeSubscription = (pubsub, subscribers, strategy) => map(deferredMake(), deferred => unsafeMakeSubscription(pubsub, subscribers, pubsub.subscribe(), unbounded$1(), deferred, make(false), strategy));
 
 /** @internal */
-const unsafeMakeSubscription = (hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => {
-  return new SubscriptionImpl(hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy);
+const unsafeMakeSubscription = (pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) => {
+  return new SubscriptionImpl(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy);
 };
 
 /** @internal */
-class BoundedHubArb {
+class BoundedPubSubArb {
   publisherIndex = 0;
   subscriberCount = 0;
   subscribersIndex = 0;
@@ -141,12 +141,12 @@ class BoundedHubArb {
     const n = chunk.length;
     const size = this.publisherIndex - this.subscribersIndex;
     const available = this.capacity - size;
-    const forHub = Math.min(n, available);
-    if (forHub === 0) {
+    const forPubSub = Math.min(n, available);
+    if (forPubSub === 0) {
       return chunk;
     }
     let iteratorIndex = 0;
-    const publishAllIndex = this.publisherIndex + forHub;
+    const publishAllIndex = this.publisherIndex + forPubSub;
     while (this.publisherIndex !== publishAllIndex) {
       const a = unsafeGet(chunk, iteratorIndex++);
       const index = this.publisherIndex % this.capacity;
@@ -166,10 +166,10 @@ class BoundedHubArb {
   }
   subscribe() {
     this.subscriberCount += 1;
-    return new BoundedHubArbSubscription(this, this.publisherIndex, false);
+    return new BoundedPubSubArbSubscription(this, this.publisherIndex, false);
   }
 }
-class BoundedHubArbSubscription {
+class BoundedPubSubArbSubscription {
   constructor(self, subscriberIndex, unsubscribed) {
     this.self = self;
     this.subscriberIndex = subscriberIndex;
@@ -246,7 +246,7 @@ class BoundedHubArbSubscription {
 }
 
 /** @internal */
-class BoundedHubPow2 {
+class BoundedPubSubPow2 {
   publisherIndex = 0;
   subscriberCount = 0;
   subscribersIndex = 0;
@@ -286,12 +286,12 @@ class BoundedHubPow2 {
     const n = chunk.length;
     const size = this.publisherIndex - this.subscribersIndex;
     const available = this.capacity - size;
-    const forHub = Math.min(n, available);
-    if (forHub === 0) {
+    const forPubSub = Math.min(n, available);
+    if (forPubSub === 0) {
       return chunk;
     }
     let iteratorIndex = 0;
-    const publishAllIndex = this.publisherIndex + forHub;
+    const publishAllIndex = this.publisherIndex + forPubSub;
     while (this.publisherIndex !== publishAllIndex) {
       const elem = unsafeGet(chunk, iteratorIndex++);
       const index = this.publisherIndex & this.mask;
@@ -311,12 +311,12 @@ class BoundedHubPow2 {
   }
   subscribe() {
     this.subscriberCount += 1;
-    return new BoundedHubPow2Subscription(this, this.publisherIndex, false);
+    return new BoundedPubSubPow2Subscription(this, this.publisherIndex, false);
   }
 }
 
 /** @internal */
-class BoundedHubPow2Subscription {
+class BoundedPubSubPow2Subscription {
   constructor(self, subscriberIndex, unsubscribed) {
     this.self = self;
     this.subscriberIndex = subscriberIndex;
@@ -393,7 +393,7 @@ class BoundedHubPow2Subscription {
 }
 
 /** @internal */
-class BoundedHubSingle {
+class BoundedPubSubSingle {
   publisherIndex = 0;
   subscriberCount = 0;
   subscribers = 0;
@@ -441,12 +441,12 @@ class BoundedHubSingle {
   }
   subscribe() {
     this.subscriberCount += 1;
-    return new BoundedHubSingleSubscription(this, this.publisherIndex, false);
+    return new BoundedPubSubSingleSubscription(this, this.publisherIndex, false);
   }
 }
 
 /** @internal */
-class BoundedHubSingleSubscription {
+class BoundedPubSubSingleSubscription {
   constructor(self, subscriberIndex, unsubscribed) {
     this.self = self;
     this.subscriberIndex = subscriberIndex;
@@ -506,7 +506,7 @@ class Node {
 }
 
 /** @internal */
-class UnboundedHub {
+class UnboundedPubSub {
   publisherHead = new Node(null, 0, null);
   publisherIndex = 0;
   subscribersIndex = 0;
@@ -547,12 +547,12 @@ class UnboundedHub {
   }
   subscribe() {
     this.publisherTail.subscribers += 1;
-    return new UnboundedHubSubscription(this, this.publisherTail, this.publisherIndex, false);
+    return new UnboundedPubSubSubscription(this, this.publisherTail, this.publisherIndex, false);
   }
 }
 
 /** @internal */
-class UnboundedHubSubscription {
+class UnboundedPubSubSubscription {
   constructor(self, subscriberHead, subscriberIndex, unsubscribed) {
     this.self = self;
     this.subscriberHead = subscriberHead;
@@ -650,8 +650,8 @@ class UnboundedHubSubscription {
 /** @internal */
 class SubscriptionImpl {
   [DequeueTypeId] = dequeueVariance;
-  constructor(hub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) {
-    this.hub = hub;
+  constructor(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy) {
+    this.pubsub = pubsub;
     this.subscribers = subscribers;
     this.subscription = subscription;
     this.pollers = pollers;
@@ -663,7 +663,7 @@ class SubscriptionImpl {
     return pipeArguments(this, arguments);
   }
   capacity() {
-    return this.hub.capacity;
+    return this.pubsub.capacity;
   }
   isActive() {
     return !get(this.shutdownFlag);
@@ -689,7 +689,7 @@ class SubscriptionImpl {
       return pipe(forEachParUnbounded(unsafePollAllQueue(this.pollers), d => deferredInterruptWith(d, state.id()), false), zipRight(sync(() => {
         this.subscribers.delete(this.subscription);
         this.subscription.unsubscribe();
-        this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
+        this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
       })), whenEffect(deferredSucceed(this.shutdownHook, void 0)), asUnit);
     }));
   }
@@ -710,11 +710,11 @@ class SubscriptionImpl {
         return pipe(suspend(() => {
           pipe(this.pollers, offer(deferred));
           pipe(this.subscribers, addSubscribers(this.subscription, this.pollers));
-          this.strategy.unsafeCompletePollers(this.hub, this.subscribers, this.subscription, this.pollers);
+          this.strategy.unsafeCompletePollers(this.pubsub, this.subscribers, this.subscription, this.pollers);
           return get(this.shutdownFlag) ? interrupt : deferredAwait(deferred);
         }), onInterrupt(() => sync(() => unsafeRemove(this.pollers, deferred))));
       } else {
-        this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
+        this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
         return succeed(message);
       }
     });
@@ -725,7 +725,7 @@ class SubscriptionImpl {
         return interrupt;
       }
       const as = isEmpty$2(this.pollers) ? unsafePollAllSubscription(this.subscription) : empty();
-      this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
+      this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
       return succeed(as);
     });
   }
@@ -735,7 +735,7 @@ class SubscriptionImpl {
         return interrupt;
       }
       const as = isEmpty$2(this.pollers) ? unsafePollN(this.subscription, max) : empty();
-      this.strategy.unsafeOnHubEmptySpace(this.hub, this.subscribers);
+      this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers);
       return succeed(as);
     });
   }
@@ -762,10 +762,10 @@ const takeRemainderLoop = (self, min, max, acc) => {
 };
 
 /** @internal */
-class HubImpl {
+class PubSubImpl {
   [EnqueueTypeId] = enqueueVariance;
-  constructor(hub, subscribers, scope, shutdownHook, shutdownFlag, strategy) {
-    this.hub = hub;
+  constructor(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) {
+    this.pubsub = pubsub;
     this.subscribers = subscribers;
     this.scope = scope;
     this.shutdownHook = shutdownHook;
@@ -773,16 +773,16 @@ class HubImpl {
     this.strategy = strategy;
   }
   capacity() {
-    return this.hub.capacity;
+    return this.pubsub.capacity;
   }
   size() {
-    return suspend(() => get(this.shutdownFlag) ? interrupt : sync(() => this.hub.size()));
+    return suspend(() => get(this.shutdownFlag) ? interrupt : sync(() => this.pubsub.size()));
   }
   unsafeSize() {
     if (get(this.shutdownFlag)) {
       return none();
     }
-    return some(this.hub.size());
+    return some(this.pubsub.size());
   }
   isFull() {
     return map(this.size(), size => size === this.capacity());
@@ -807,11 +807,11 @@ class HubImpl {
       if (get(this.shutdownFlag)) {
         return interrupt;
       }
-      if (this.hub.publish(value)) {
-        this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
+      if (this.pubsub.publish(value)) {
+        this.strategy.unsafeCompleteSubscribers(this.pubsub, this.subscribers);
         return succeed(true);
       }
-      return this.strategy.handleSurplus(this.hub, this.subscribers, of(value), this.shutdownFlag);
+      return this.strategy.handleSurplus(this.pubsub, this.subscribers, of(value), this.shutdownFlag);
     });
   }
   isActive() {
@@ -821,8 +821,8 @@ class HubImpl {
     if (get(this.shutdownFlag)) {
       return false;
     }
-    if (this.hub.publish(value)) {
-      this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
+    if (this.pubsub.publish(value)) {
+      this.strategy.unsafeCompleteSubscribers(this.pubsub, this.subscribers);
       return true;
     }
     return false;
@@ -832,16 +832,16 @@ class HubImpl {
       if (get(this.shutdownFlag)) {
         return interrupt;
       }
-      const surplus = unsafePublishAll(this.hub, elements);
-      this.strategy.unsafeCompleteSubscribers(this.hub, this.subscribers);
+      const surplus = unsafePublishAll(this.pubsub, elements);
+      this.strategy.unsafeCompleteSubscribers(this.pubsub, this.subscribers);
       if (isEmpty$1(surplus)) {
         return succeed(true);
       }
-      return this.strategy.handleSurplus(this.hub, this.subscribers, surplus, this.shutdownFlag);
+      return this.strategy.handleSurplus(this.pubsub, this.subscribers, surplus, this.shutdownFlag);
     });
   }
   subscribe() {
-    const acquire = tap(all([this.scope.fork(sequential), makeSubscription(this.hub, this.subscribers, this.strategy)]), tuple => tuple[0].addFinalizer(() => tuple[1].shutdown()));
+    const acquire = tap(all([this.scope.fork(sequential), makeSubscription(this.pubsub, this.subscribers, this.strategy)]), tuple => tuple[0].addFinalizer(() => tuple[1].shutdown()));
     return map(acquireRelease(acquire, (tuple, exit) => tuple[0].close(exit)), tuple => tuple[1]);
   }
   offer(value) {
@@ -856,11 +856,11 @@ class HubImpl {
 }
 
 /** @internal */
-const makeHub = (hub, strategy) => flatMap(scopeMake(), scope => map(deferredMake(), deferred => unsafeMakeHub(hub, new Map(), scope, deferred, make(false), strategy)));
+const makePubSub = (pubsub, strategy) => flatMap(scopeMake(), scope => map(deferredMake(), deferred => unsafeMakePubSub(pubsub, new Map(), scope, deferred, make(false), strategy)));
 
 /** @internal */
-const unsafeMakeHub = (hub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => {
-  return new HubImpl(hub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
+const unsafeMakePubSub = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => {
+  return new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
 };
 
 /** @internal */
@@ -872,7 +872,7 @@ const nextPow2 = n => {
 /** @internal */
 const ensureCapacity = capacity => {
   if (capacity <= 0) {
-    throw InvalidHubCapacityException(`Cannot construct Hub with capacity of ${capacity}`);
+    throw InvalidPubSubCapacityException(`Cannot construct PubSub with capacity of ${capacity}`);
   }
 };
 
@@ -902,8 +902,8 @@ const unsafePollN = (subscription, max) => {
 };
 
 /** @internal */
-const unsafePublishAll = (hub, as) => {
-  return hub.publishAll(as);
+const unsafePublishAll = (pubsub, as) => {
+  return pubsub.publishAll(as);
 };
 
 /** @internal */
@@ -912,19 +912,19 @@ const unsafeRemove = (queue, value) => {
 };
 
 // -----------------------------------------------------------------------------
-// Hub.Strategy
+// PubSub.Strategy
 // -----------------------------------------------------------------------------
 
 /**
- * A `HubStrategy<A>` describes the protocol for how publishers and subscribers
- * will communicate with each other through the hub.
+ * A `PubSubStrategy<A>` describes the protocol for how publishers and subscribers
+ * will communicate with each other through the `PubSub`.
  *
  * @internal
  */
 /**
- * A strategy that applies back pressure to publishers when the hub is at
+ * A strategy that applies back pressure to publishers when the `PubSub` is at
  * capacity. This guarantees that all subscribers will receive all messages
- * published to the hub while they are subscribed. However, it creates the
+ * published to the `PubSub` while they are subscribed. However, it creates the
  * risk that a slow subscriber will slow down the rate at which messages
  * are published and received by other subscribers.
  *
@@ -935,39 +935,39 @@ class BackPressureStrategy {
   shutdown() {
     return flatMap(fiberId, fiberId => flatMap(sync(() => unsafePollAllQueue(this.publishers)), publishers => forEachParUnboundedDiscard(publishers, ([_, deferred, last]) => last ? pipe(deferredInterruptWith(deferred, fiberId), asUnit) : unit, false)));
   }
-  handleSurplus(hub, subscribers, elements, isShutdown) {
+  handleSurplus(pubsub, subscribers, elements, isShutdown) {
     return withFiberRuntime(state => {
       const deferred = deferredUnsafeMake(state.id());
       return pipe(suspend(() => {
         this.unsafeOffer(elements, deferred);
-        this.unsafeOnHubEmptySpace(hub, subscribers);
-        this.unsafeCompleteSubscribers(hub, subscribers);
+        this.unsafeOnPubSubEmptySpace(pubsub, subscribers);
+        this.unsafeCompleteSubscribers(pubsub, subscribers);
         return get(isShutdown) ? interrupt : deferredAwait(deferred);
       }), onInterrupt(() => sync(() => this.unsafeRemove(deferred))));
     });
   }
-  unsafeOnHubEmptySpace(hub, subscribers) {
+  unsafeOnPubSubEmptySpace(pubsub, subscribers) {
     let keepPolling = true;
-    while (keepPolling && !hub.isFull()) {
+    while (keepPolling && !pubsub.isFull()) {
       const publisher = pipe(this.publishers, poll(EmptyMutableQueue));
       if (publisher === EmptyMutableQueue) {
         keepPolling = false;
       } else {
-        const published = hub.publish(publisher[0]);
+        const published = pubsub.publish(publisher[0]);
         if (published && publisher[2]) {
           unsafeCompleteDeferred(publisher[1], true);
         } else if (!published) {
           unsafeOfferAll(this.publishers, pipe(unsafePollAllQueue(this.publishers), prepend(publisher)));
         }
-        this.unsafeCompleteSubscribers(hub, subscribers);
+        this.unsafeCompleteSubscribers(pubsub, subscribers);
       }
     }
   }
-  unsafeCompletePollers(hub, subscribers, subscription, pollers) {
-    return unsafeStrategyCompletePollers(this, hub, subscribers, subscription, pollers);
+  unsafeCompletePollers(pubsub, subscribers, subscription, pollers) {
+    return unsafeStrategyCompletePollers(this, pubsub, subscribers, subscription, pollers);
   }
-  unsafeCompleteSubscribers(hub, subscribers) {
-    return unsafeStrategyCompleteSubscribers(this, hub, subscribers);
+  unsafeCompleteSubscribers(pubsub, subscribers) {
+    return unsafeStrategyCompleteSubscribers(this, pubsub, subscribers);
   }
   unsafeOffer(elements, deferred) {
     const iterator = elements[Symbol.iterator]();
@@ -991,12 +991,12 @@ class BackPressureStrategy {
 }
 
 /**
- * A strategy that drops new messages when the hub is at capacity. This
+ * A strategy that drops new messages when the `PubSub` is at capacity. This
  * guarantees that a slow subscriber will not slow down the rate at which
  * messages are published. However, it creates the risk that a slow
  * subscriber will slow down the rate at which messages are received by
  * other subscribers and that subscribers may not receive all messages
- * published to the hub while they are subscribed.
+ * published to the `PubSub` while they are subscribed.
  *
  * @internal
  */
@@ -1004,26 +1004,26 @@ class DroppingStrategy {
   shutdown() {
     return unit;
   }
-  handleSurplus(_hub, _subscribers, _elements, _isShutdown) {
+  handleSurplus(_pubsub, _subscribers, _elements, _isShutdown) {
     return succeed(false);
   }
-  unsafeOnHubEmptySpace(_hub, _subscribers) {
+  unsafeOnPubSubEmptySpace(_pubsub, _subscribers) {
     //
   }
-  unsafeCompletePollers(hub, subscribers, subscription, pollers) {
-    return unsafeStrategyCompletePollers(this, hub, subscribers, subscription, pollers);
+  unsafeCompletePollers(pubsub, subscribers, subscription, pollers) {
+    return unsafeStrategyCompletePollers(this, pubsub, subscribers, subscription, pollers);
   }
-  unsafeCompleteSubscribers(hub, subscribers) {
-    return unsafeStrategyCompleteSubscribers(this, hub, subscribers);
+  unsafeCompleteSubscribers(pubsub, subscribers) {
+    return unsafeStrategyCompleteSubscribers(this, pubsub, subscribers);
   }
 }
 
 /**
- * A strategy that adds new messages and drops old messages when the hub is
+ * A strategy that adds new messages and drops old messages when the `PubSub` is
  * at capacity. This guarantees that a slow subscriber will not slow down
  * the rate at which messages are published and received by other
  * subscribers. However, it creates the risk that a slow subscriber will
- * not receive some messages published to the hub while it is subscribed.
+ * not receive some messages published to the `PubSub` while it is subscribed.
  *
  * @internal
  */
@@ -1031,31 +1031,31 @@ class SlidingStrategy {
   shutdown() {
     return unit;
   }
-  handleSurplus(hub, subscribers, elements, _isShutdown) {
+  handleSurplus(pubsub, subscribers, elements, _isShutdown) {
     return sync(() => {
-      this.unsafeSlidingPublish(hub, elements);
-      this.unsafeCompleteSubscribers(hub, subscribers);
+      this.unsafeSlidingPublish(pubsub, elements);
+      this.unsafeCompleteSubscribers(pubsub, subscribers);
       return true;
     });
   }
-  unsafeOnHubEmptySpace(_hub, _subscribers) {
+  unsafeOnPubSubEmptySpace(_pubsub, _subscribers) {
     //
   }
-  unsafeCompletePollers(hub, subscribers, subscription, pollers) {
-    return unsafeStrategyCompletePollers(this, hub, subscribers, subscription, pollers);
+  unsafeCompletePollers(pubsub, subscribers, subscription, pollers) {
+    return unsafeStrategyCompletePollers(this, pubsub, subscribers, subscription, pollers);
   }
-  unsafeCompleteSubscribers(hub, subscribers) {
-    return unsafeStrategyCompleteSubscribers(this, hub, subscribers);
+  unsafeCompleteSubscribers(pubsub, subscribers) {
+    return unsafeStrategyCompleteSubscribers(this, pubsub, subscribers);
   }
-  unsafeSlidingPublish(hub, elements) {
+  unsafeSlidingPublish(pubsub, elements) {
     const it = elements[Symbol.iterator]();
     let next = it.next();
-    if (!next.done && hub.capacity > 0) {
+    if (!next.done && pubsub.capacity > 0) {
       let a = next.value;
       let loop = true;
       while (loop) {
-        hub.slide();
-        const pub = hub.publish(a);
+        pubsub.slide();
+        const pub = pubsub.publish(a);
         if (pub && (next = it.next()) && !next.done) {
           a = next.value;
         } else if (pub) {
@@ -1067,7 +1067,7 @@ class SlidingStrategy {
 }
 
 /** @internal */
-const unsafeStrategyCompletePollers = (strategy, hub, subscribers, subscription, pollers) => {
+const unsafeStrategyCompletePollers = (strategy, pubsub, subscribers, subscription, pollers) => {
   let keepPolling = true;
   while (keepPolling && !subscription.isEmpty()) {
     const poller = pipe(pollers, poll(EmptyMutableQueue));
@@ -1084,19 +1084,19 @@ const unsafeStrategyCompletePollers = (strategy, hub, subscribers, subscription,
         unsafeOfferAll(pollers, pipe(unsafePollAllQueue(pollers), prepend(poller)));
       } else {
         unsafeCompleteDeferred(poller, pollResult);
-        strategy.unsafeOnHubEmptySpace(hub, subscribers);
+        strategy.unsafeOnPubSubEmptySpace(pubsub, subscribers);
       }
     }
   }
 };
 
 /** @internal */
-const unsafeStrategyCompleteSubscribers = (strategy, hub, subscribers) => {
+const unsafeStrategyCompleteSubscribers = (strategy, pubsub, subscribers) => {
   for (const [subscription, pollersSet] of subscribers) {
     for (const pollers of pollersSet) {
-      strategy.unsafeCompletePollers(hub, subscribers, subscription, pollers);
+      strategy.unsafeCompletePollers(pubsub, subscribers, subscription, pollers);
     }
   }
 };
 
-export { DroppingStrategy, SlidingStrategy, awaitShutdown, bounded, capacity, dropping, isEmpty, isFull, isShutdown, makeHub, publish, publishAll, shutdown, size, sliding, subscribe, unbounded, unsafeMakeHub, unsafeMakeSubscription };
+export { DroppingStrategy, SlidingStrategy, awaitShutdown, bounded, capacity, dropping, isEmpty, isFull, isShutdown, makePubSub, publish, publishAll, shutdown, size, sliding, subscribe, unbounded, unsafeMakePubSub, unsafeMakeSubscription };

package/internal/request.esm.js

@@ -1,7 +1,7 @@
-import { struct } from '../Data/dist/effect-Data.esm.js';
 import { dual } from '../Function/dist/effect-Function.esm.js';
 import { currentRequestMap } from './completedRequestMap.esm.js';
 import { fiberRefGetWith, sync, deferredUnsafeDone, matchEffect, exitFail, exitSucceed } from './core.esm.js';
+import { struct } from './Data.esm.js';
 
 /** @internal */
 const RequestSymbolKey = "effect/Request";

package/internal/sink.esm.js

@@ -8,13 +8,13 @@ import { match as match$2 } from '../Exit/dist/effect-Exit.esm.js';
 import { dual, pipe, constTrue, identity } from '../Function/dist/effect-Function.esm.js';
 import { empty as empty$1, has, unsafeGet, set } from '../HashMap/dist/effect-HashMap.esm.js';
 import { empty as empty$2, has as has$1, add } from '../HashSet/dist/effect-HashSet.esm.js';
-import { bounded } from '../Hub/dist/effect-Hub.esm.js';
 import { some as some$1, none, match as match$1, isNone, orElse as orElse$2 } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { bounded } from '../PubSub/dist/effect-PubSub.esm.js';
 import { shutdown, offerAll } from '../Queue/dist/effect-Queue.esm.js';
 import { span } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 import { make, set as set$1, get } from '../Ref/dist/effect-Ref.esm.js';
-import { zipRight as zipRight$1, as as as$1, bufferChunk, foldChannel, doneCollect, map as map$2, pipeToOrFail, drain as drain$1, identityChannel, ensuring as ensuring$1, unwrap as unwrap$1, catchAll, unwrapScoped as unwrapScoped$1, mapEffect as mapEffect$1, mapError as mapError$1, mapOut, orElse as orElse$1, fromHubScoped, toHub, mergeWith, writeChunk } from './channel.esm.js';
+import { zipRight as zipRight$1, as as as$1, bufferChunk, foldChannel, doneCollect, map as map$2, pipeToOrFail, drain as drain$1, identityChannel, ensuring as ensuring$1, unwrap as unwrap$1, catchAll, unwrapScoped as unwrapScoped$1, mapEffect as mapEffect$1, mapError as mapError$1, mapOut, orElse as orElse$1, fromPubSubScoped, toPubSub, mergeWith, writeChunk } from './channel.esm.js';
 import { Done, Await } from './channel/mergeDecision.esm.js';
 import { suspend as suspend$1, readWithCause, failCause as failCause$1, succeed as succeed$1, readWith, write, fail as fail$1, flatMap as flatMap$1, fromEffect as fromEffect$1, pipeTo, collectElements, succeedNow, ensuringWith as ensuringWith$1, failSync as failSync$1, failCauseSync as failCauseSync$1, unit, provideContext as provideContext$1, sync as sync$1 } from './core-stream.esm.js';
 
@@ -673,7 +673,7 @@ const fromChannel = channel => new SinkImpl(channel);
 const fromEffect = effect => new SinkImpl(fromEffect$1(effect));
 
 /** @internal */
-const fromHub = (hub, options) => fromQueue(hub, options);
+const fromPubSub = (pubsub, options) => fromQueue(pubsub, options);
 
 /** @internal */
 const fromPush = push => new SinkImpl(unwrapScoped$1(pipe(push, map$1(fromPushPull))));
@@ -750,10 +750,10 @@ const raceBoth = /*#__PURE__*/dual(args => isSink(args[1]), (self, that, options
 /** @internal */
 const raceWith = /*#__PURE__*/dual(2, (self, options) => {
   const scoped = gen(function* ($) {
-    const hub = yield* $(bounded(options?.capacity ?? 16));
-    const channel1 = yield* $(fromHubScoped(hub));
-    const channel2 = yield* $(fromHubScoped(hub));
-    const reader = toHub(hub);
+    const pubsub = yield* $(bounded(options?.capacity ?? 16));
+    const channel1 = yield* $(fromPubSubScoped(pubsub));
+    const channel2 = yield* $(fromPubSubScoped(pubsub));
+    const reader = toPubSub(pubsub);
     const writer = pipe(channel1, pipeTo(toChannel(self)), mergeWith({
       other: pipe(channel2, pipeTo(toChannel(options.other))),
       onSelfDone: options.onSelfDone,
@@ -915,4 +915,4 @@ const mkString = /*#__PURE__*/suspend(() => {
 /** @internal */
 const timed = /*#__PURE__*/pipe( /*#__PURE__*/withDuration(drain), /*#__PURE__*/map(tuple => tuple[1]));
 
-export { SinkImpl, SinkTypeId, as, channelToSink, collectAll, collectAllFrom, collectAllN, collectAllToMap, collectAllToMapN, collectAllToSet, collectAllToSetN, collectAllUntil, collectAllUntilEffect, collectAllWhile, collectAllWhileEffect, collectAllWhileWith, collectLeftover, context, contextWith, contextWithEffect, contextWithSink, count, die, dieMessage, dieSync, dimap, dimapChunks, dimapChunksEffect, dimapEffect, drain, drop, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, ensuring, ensuringWith, every, fail, failCause, failCauseSync, failSync, filterInput, filterInputEffect, findEffect, flatMap, fold, foldChunks, foldChunksEffect, foldEffect, foldLeft, foldLeftChunks, foldLeftChunksEffect, foldLeftEffect, foldSink, foldUntil, foldUntilEffect, foldWeighted, foldWeightedDecompose, foldWeightedDecomposeEffect, foldWeightedEffect, forEach, forEachChunk, forEachChunkWhile, forEachWhile, fromChannel, fromEffect, fromHub, fromPush, fromQueue, head, ignoreLeftover, isSink, last, leftover, map, mapEffect, mapError, mapInput, mapInputChunks, mapInputChunksEffect, mapInputEffect, mapLeftover, mkString, never, orElse, provideContext, race, raceBoth, raceWith, refineOrDie, refineOrDieWith, some, splitWhere, succeed, sum, summarized, suspend, sync, take, timed, toChannel, unwrap, unwrapScoped, withDuration, zip, zipLeft, zipRight, zipWith };
+export { SinkImpl, SinkTypeId, as, channelToSink, collectAll, collectAllFrom, collectAllN, collectAllToMap, collectAllToMapN, collectAllToSet, collectAllToSetN, collectAllUntil, collectAllUntilEffect, collectAllWhile, collectAllWhileEffect, collectAllWhileWith, collectLeftover, context, contextWith, contextWithEffect, contextWithSink, count, die, dieMessage, dieSync, dimap, dimapChunks, dimapChunksEffect, dimapEffect, drain, drop, dropUntil, dropUntilEffect, dropWhile, dropWhileEffect, ensuring, ensuringWith, every, fail, failCause, failCauseSync, failSync, filterInput, filterInputEffect, findEffect, flatMap, fold, foldChunks, foldChunksEffect, foldEffect, foldLeft, foldLeftChunks, foldLeftChunksEffect, foldLeftEffect, foldSink, foldUntil, foldUntilEffect, foldWeighted, foldWeightedDecompose, foldWeightedDecomposeEffect, foldWeightedEffect, forEach, forEachChunk, forEachChunkWhile, forEachWhile, fromChannel, fromEffect, fromPubSub, fromPush, fromQueue, head, ignoreLeftover, isSink, last, leftover, map, mapEffect, mapError, mapInput, mapInputChunks, mapInputChunksEffect, mapInputEffect, mapLeftover, mkString, never, orElse, provideContext, race, raceBoth, raceWith, refineOrDie, refineOrDieWith, some, splitWhere, succeed, sum, summarized, suspend, sync, take, timed, toChannel, unwrap, unwrapScoped, withDuration, zip, zipLeft, zipRight, zipWith };