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

package/internal/channel.esm.js

@@ -8,9 +8,9 @@ import { equals } from '../Equal/dist/effect-Equal.esm.js';
 import { failCause as failCause$3, match as match$3, succeed as succeed$3, zip as zip$2 } from '../Exit/dist/effect-Exit.esm.js';
 import { interrupt, join, await as _await$1 } from '../Fiber/dist/effect-Fiber.esm.js';
 import { pipe, dual, constVoid, identity } from '../Function/dist/effect-Function.esm.js';
-import { subscribe } from '../Hub/dist/effect-Hub.esm.js';
 import { build, merge, context as context$2 } from '../Layer/dist/effect-Layer.esm.js';
 import { match as match$1, none, some, isSome } from '../Option/dist/effect-Option.esm.js';
+import { subscribe } from '../PubSub/dist/effect-PubSub.esm.js';
 import { take, bounded, shutdown, offer, unbounded, size } from '../Queue/dist/effect-Queue.esm.js';
 import { make, get, set, update, modify } from '../Ref/dist/effect-Ref.esm.js';
 import { make as make$3, extend, close } from '../Scope/dist/effect-Scope.esm.js';
@@ -209,10 +209,10 @@ const fromEither = either => suspend(() => match(either, {
 const fromInput = input => unwrap(input.takeWith(failCause, elem => flatMap(write(elem), () => fromInput(input)), succeed));
 
 /** @internal */
-const fromHub = hub => unwrapScoped(map$1(subscribe(hub), fromQueue));
+const fromPubSub = pubsub => unwrapScoped(map$1(subscribe(pubsub), fromQueue));
 
 /** @internal */
-const fromHubScoped = hub => map$1(subscribe(hub), fromQueue);
+const fromPubSubScoped = pubsub => map$1(subscribe(pubsub), fromQueue);
 
 /** @internal */
 const fromOption = option => suspend(() => match$1(option, {
@@ -546,7 +546,7 @@ const runDrain = self => run$1(drain(self));
 const scoped = effect => unwrap(uninterruptibleMask(restore => map$1(make$3(), scope => acquireReleaseOut(tapErrorCause(restore(extend(scope)(effect)), cause => close(scope, failCause$3(cause))), (_, exit) => close(scope, exit)))));
 
 /** @internal */
-const toHub = hub => toQueue(hub);
+const toPubSub = pubsub => toQueue(pubsub);
 
 /** @internal */
 const toPull = self => map$1(acquireRelease(sync$1(() => new ChannelExecutor(self, void 0, identity)), (exec, exit) => {
@@ -645,4 +645,4 @@ const ChannelException = error => ({
 /** @internal */
 const isChannelException = u => typeof u === "object" && u != null && ChannelExceptionTypeId in u;
 
-export { ChannelException, ChannelExceptionTypeId, acquireUseRelease, as, asUnit, buffer, bufferChunk, catchAll, collect, concatMap, concatOut, context, contextWith, contextWithChannel, contextWithEffect, doneCollect, drain, emitCollect, ensuring, flatten, foldChannel, fromEither, fromHub, fromHubScoped, fromInput, fromOption, fromQueue, identityChannel, interruptWhen, interruptWhenDeferred, isChannelException, map, mapEffect, mapError, mapErrorCause, mapInput, mapInputContext, mapInputEffect, mapInputError, mapInputErrorEffect, mapInputIn, mapInputInEffect, mapOut, mapOutEffect, mapOutEffectPar, mergeAll, mergeAllUnbounded, mergeAllUnboundedWith, mergeAllWith, mergeMap, mergeOut, mergeOutWith, mergeWith, never, orDie, orDieWith, orElse, pipeToOrFail, provideLayer, provideService, provideSomeLayer, read, repeated, run, runCollect, runDrain, scoped, toHub, toPull, toQueue, unwrap, unwrapScoped, updateService, withSpan, writeAll, writeChunk, zip, zipLeft, zipRight };
+export { ChannelException, ChannelExceptionTypeId, acquireUseRelease, as, asUnit, buffer, bufferChunk, catchAll, collect, concatMap, concatOut, context, contextWith, contextWithChannel, contextWithEffect, doneCollect, drain, emitCollect, ensuring, flatten, foldChannel, fromEither, fromInput, fromOption, fromPubSub, fromPubSubScoped, fromQueue, identityChannel, interruptWhen, interruptWhenDeferred, isChannelException, map, mapEffect, mapError, mapErrorCause, mapInput, mapInputContext, mapInputEffect, mapInputError, mapInputErrorEffect, mapInputIn, mapInputInEffect, mapOut, mapOutEffect, mapOutEffectPar, mergeAll, mergeAllUnbounded, mergeAllUnboundedWith, mergeAllWith, mergeMap, mergeOut, mergeOutWith, mergeWith, never, orDie, orDieWith, orElse, pipeToOrFail, provideLayer, provideService, provideSomeLayer, read, repeated, run, runCollect, runDrain, scoped, toPubSub, toPull, toQueue, unwrap, unwrapScoped, updateService, withSpan, writeAll, writeChunk, zip, zipLeft, zipRight };

package/internal/core-effect.esm.js

@@ -9,7 +9,7 @@ import { dual, identity, constVoid, constTrue, constFalse, pipe } from '../Funct
 import { set, forEach } from '../HashMap/dist/effect-HashMap.esm.js';
 import { fromIterable as fromIterable$1, union, size } from '../HashSet/dist/effect-HashSet.esm.js';
 import { fail, find, isDieType, empty, failures, failureOrCause, keepDefects, flatten, NoSuchElementException, isNoSuchElementException, interruptors, IllegalArgumentException, isCause } from './cause.esm.js';
-import { fiberRefLocallyWith, currentLogAnnotations, isEffect, map, mapError, asyncEither, unit, sync, makeEffectError, catchAll, fail as fail$1, catchAllCause, unified, failCause, matchCauseEffect, succeed, catchIf, matchCause, zipRight, withFiberRuntime, flatMap, suspend, context, orElse, yieldNow, dieSync, dieMessage, failSync, flip, matchEffect, currentLogSpan, fiberRefGet, failCauseSync, intoDeferred, deferredAwait, as, zip, updateRuntimeFlags, deferredMake, asUnit, whenEffect, async, contextWithEffect, provideContext, currentMetricLabels, mapInputContext, currentTracerSpanAnnotations, currentTracerSpan, currentTracerSpanLinks, acquireUseRelease, currentInterruptedCause, interrupt, runtimeFlags, fiberRefGetWith, currentTracerTimingEnabled, exitSucceed, exitDie, exitFail } from './core.esm.js';
+import { fiberRefLocallyWith, currentLogAnnotations, isEffect, map, mapError, asyncEither, unit, sync, makeEffectError, catchAll, fail as fail$1, catchAllCause, unified, failCause, matchCauseEffect, succeed, catchIf, matchCause, zipRight, withFiberRuntime, flatMap, suspend, context, orElse, yieldNow, dieSync, dieMessage, failSync, flip, matchEffect, currentLogSpan, fiberRefGet, failCauseSync, intoDeferred, deferredAwait, as, zip, updateRuntimeFlags, deferredMake, asUnit, whenEffect, async, contextWithEffect, provideContext, currentMetricLabels, mapInputContext, currentTracerSpanAnnotations, currentTracerSpan, currentTracerSpanLinks, acquireUseRelease, currentInterruptedCause, interrupt, runtimeFlags, fiberRefGetWith, currentTracerTimingEnabled, exitSucceed, exitDie } from './core.esm.js';
 import { randomWith } from './defaultServices.esm.js';
 import { diff, patch } from './fiberRefs/patch.esm.js';
 import { make as make$2 } from './metric/label.esm.js';
@@ -582,7 +582,9 @@ const succeedSome = value => succeed(some(value));
 const summarized = /*#__PURE__*/dual(3, (self, summary, f) => flatMap(summary, start => flatMap(self, value => map(summary, end => [f(start, end), value]))));
 
 /* @internal */
-const tagMetrics = /*#__PURE__*/dual(3, (self, key, value) => labelMetrics(self, [make$2(key, value)]));
+const tagMetrics = /*#__PURE__*/dual(args => isEffect(args[0]), function () {
+  return labelMetrics(arguments[0], typeof arguments[1] === "string" ? [make$2(arguments[1], arguments[2])] : Object.entries(arguments[1]).map(([k, v]) => make$2(k, v)));
+});
 
 /* @internal */
 const labelMetrics = /*#__PURE__*/dual(2, (self, labels) => labelMetricsSet(self, fromIterable$1(labels)));
@@ -716,13 +718,13 @@ const tryPromise = arg => {
     return suspend(() => {
       const controller = new AbortController();
       return flatMap(try_(() => evaluate(controller.signal)), promise => async(resolve => {
-        promise.then(a => resolve(exitSucceed(a))).catch(e => resolve(exitFail(catcher ? catcher(e) : e)));
+        promise.then(a => resolve(exitSucceed(a))).catch(e => resolve(fail$1(catcher ? catcher(e) : e)));
         return sync(() => controller.abort());
       }));
     });
   }
   return flatMap(try_(arg), promise => async(resolve => {
-    promise.then(a => resolve(exitSucceed(a))).catch(e => resolve(exitFail(catcher ? catcher(e) : e)));
+    promise.then(a => resolve(exitSucceed(a))).catch(e => resolve(fail$1(catcher ? catcher(e) : e)));
   }));
 };
 

package/internal/fiberRuntime.esm.js

@@ -15,7 +15,7 @@ import { clockTag } from './clock.esm.js';
 import { currentRequestMap } from './completedRequestMap.esm.js';
 import { matchSimple, match as match$1 } from './concurrency.esm.js';
 import { configProviderTag } from './configProvider.esm.js';
-import { fiberRefUnsafeMake, currentTracerSpan, fiberRefUnsafeMakeHashSet, uninterruptible, tap, isEffect, withFiberRuntime, fiberRefLocally, currentForkScopeOverride, map as map$1, exit, exitIsSuccess, onError, failCause, partitionMap, either, flatMap as flatMap$1, unit, succeed, fail, dieSync, uninterruptibleMask, interruptible, forEachSequential, zipRight, asUnit, onInterrupt, zipLeft, interruptFiber, deferredMake, exitMatchEffect, flatten, deferredFailCause, deferredSucceed, contextWithEffect, scopeFork, currentMetricLabels, acquireUseRelease, scopeClose, exitZipWith, flip, fiberIdWith, updateRuntimeFlags, runtimeFlags, ScopeTypeId, releaseMapMake, CloseableScopeTypeId, releaseMapAdd, scopeAddFinalizerExit, as, mapInputContext, onExit, fiberRefUnsafeMakePatch, fiberRefGet, fiberRefSet, fiberRefGetWith, sync, fiberRefUpdate, fiberRefDelete, fiberRefUnsafeMakeContext, fiberRefUnsafeMakeRuntimeFlags, forEachSequentialDiscard, exitSucceed, matchCauseEffect, suspend, currentInterruptedCause, deferredUnsafeMake, deferredAwait, async, currentSchedulingPriority, whileLoop, currentUnhandledErrorLogLevel, currentLogLevel, currentLogSpan, currentLogAnnotations, exitFailCause, exitUnit, currentContext, exitFail, blocked, catchAllCause, runRequestBlock, RevertFlags, yieldNow as yieldNow$1, isEffectError, withRuntimeFlags, matchEffect, if_, zipWith, currentRequestBatching, transplant, step, deferredUnsafeDone, deferredFail, exitCollectAll, exitIsFailure, exitInterrupt, exitAsUnit, interruptAsFiber, flatMapStep } from './core.esm.js';
+import { fiberRefUnsafeMake, currentTracerSpan, fiberRefUnsafeMakeHashSet, uninterruptible, tap, isEffect, withFiberRuntime, fiberRefLocally, currentForkScopeOverride, map as map$1, exit, exitIsSuccess, onError, failCause, partitionMap, either, flatMap as flatMap$1, unit, succeed, fail, dieSync, uninterruptibleMask, interruptible, forEachSequential, zipRight, asUnit, onInterrupt, zipLeft, interruptFiber, deferredMake, exitMatchEffect, flatten, deferredFailCause, deferredSucceed, contextWithEffect, scopeFork, currentMetricLabels, acquireUseRelease, scopeClose, exitZipWith, flip, fiberIdWith, updateRuntimeFlags, runtimeFlags, ScopeTypeId, releaseMapMake, CloseableScopeTypeId, releaseMapAdd, scopeAddFinalizerExit, as, mapInputContext, onExit, fiberRefUnsafeMakePatch, fiberRefGet, fiberRefSet, fiberRefGetWith, sync, fiberRefUpdate, fiberRefDelete, fiberRefUnsafeMakeContext, fiberRefUnsafeMakeRuntimeFlags, forEachSequentialDiscard, exitSucceed, matchCauseEffect, suspend, currentInterruptedCause, deferredUnsafeMake, deferredAwait, async, currentSchedulingPriority, whileLoop, currentUnhandledErrorLogLevel, currentLogLevel, currentLogSpan, currentLogAnnotations, exitFailCause, exitUnit, currentContext, blocked, catchAllCause, runRequestBlock, RevertFlags, yieldNow as yieldNow$1, isEffectError, withRuntimeFlags, matchEffect, if_, zipWith, currentRequestBatching, transplant, step, deferredUnsafeDone, deferredFail, exitCollectAll, exitIsFailure, exitInterrupt, exitAsUnit, interruptAsFiber, flatMapStep } from './core.esm.js';
 import { makeSpan, currentTimeNanosTracing, mapErrorCause } from './core-effect.esm.js';
 import { currentServices } from './defaultServices.esm.js';
 import { consoleTag } from './defaultServices/console.esm.js';
@@ -878,10 +878,10 @@ class FiberRuntime {
     });
   }
   ["Left"](op) {
-    return exitFail(op.left);
+    return fail(op.left);
   }
   ["None"](_) {
-    return exitFail(NoSuchElementException());
+    return fail(NoSuchElementException());
   }
   ["Right"](op) {
     return exitSucceed(op.right);

package/internal/layer.esm.js

@@ -552,7 +552,7 @@ const unwrapScoped = self => {
 // -----------------------------------------------------------------------------
 
 /** @internal */
-const withSpan = /*#__PURE__*/dual(2, (self, name, options) => unwrapScoped(map$1(useSpanScoped(name, options), span => locallyEffect(self, withParentSpan(span)))));
+const withSpan = /*#__PURE__*/dual(args => isLayer(args[0]), (self, name, options) => unwrapScoped(map$1(useSpanScoped(name, options), span => locallyEffect(self, withParentSpan(span)))));
 
 // circular with Effect
 

package/internal/metric/hook.esm.js

@@ -41,14 +41,18 @@ const onUpdate = /*#__PURE__*/dual(2, (self, f) => ({
     return f(input);
   }
 }));
+const bigint0 = /*#__PURE__*/BigInt(0);
 
 /** @internal */
-const counter = _key => {
-  let sum = 0;
+const counter = key => {
+  let sum = key.keyType.bigint ? bigint0 : 0;
+  const canUpdate = key.keyType.incremental ? key.keyType.bigint ? value => value >= bigint0 : value => value >= 0 : _value => true;
   return make({
     get: () => counter$1(sum),
     update: value => {
-      sum = sum + value;
+      if (canUpdate(value)) {
+        sum = sum + value;
+      }
     }
   });
 };

package/internal/metric/key.esm.js

@@ -42,13 +42,13 @@ class MetricKeyImpl {
 const isMetricKey = u => typeof u === "object" && u != null && MetricKeyTypeId in u;
 
 /** @internal */
-const counter = (name, description) => new MetricKeyImpl(name, counter$1, fromNullable(description));
+const counter = (name, options) => new MetricKeyImpl(name, counter$1(options), fromNullable(options?.description));
 
 /** @internal */
 const frequency = (name, description) => new MetricKeyImpl(name, frequency$1, fromNullable(description));
 
 /** @internal */
-const gauge = (name, description) => new MetricKeyImpl(name, gauge$1, fromNullable(description));
+const gauge = (name, options) => new MetricKeyImpl(name, gauge$1(options), fromNullable(options?.description));
 
 /** @internal */
 const histogram = (name, boundaries, description) => new MetricKeyImpl(name, histogram$1(boundaries), fromNullable(description));

package/internal/metric/keyType.esm.js

@@ -50,6 +50,10 @@ const metricKeyTypeVariance = {
 class CounterKeyType {
   [MetricKeyTypeTypeId] = metricKeyTypeVariance;
   [CounterKeyTypeTypeId] = CounterKeyTypeTypeId;
+  constructor(incremental, bigint) {
+    this.incremental = incremental;
+    this.bigint = bigint;
+  }
   [symbol]() {
     return hash(CounterKeyTypeSymbolKey);
   }
@@ -80,6 +84,9 @@ class FrequencyKeyType {
 class GaugeKeyType {
   [MetricKeyTypeTypeId] = metricKeyTypeVariance;
   [GaugeKeyTypeTypeId] = GaugeKeyTypeTypeId;
+  constructor(bigint) {
+    this.bigint = bigint;
+  }
   [symbol]() {
     return hash(GaugeKeyTypeSymbolKey);
   }
@@ -137,7 +144,7 @@ class SummaryKeyType {
  * @since 2.0.0
  * @category constructors
  */
-const counter = /*#__PURE__*/new CounterKeyType();
+const counter = options => new CounterKeyType(options?.incremental ?? false, options?.bigint ?? false);
 
 /**
  * @since 2.0.0
@@ -149,7 +156,7 @@ const frequency = /*#__PURE__*/new FrequencyKeyType();
  * @since 2.0.0
  * @category constructors
  */
-const gauge = /*#__PURE__*/new GaugeKeyType();
+const gauge = options => new GaugeKeyType(options?.bigint ?? false);
 
 /**
  * @since 2.0.0

package/internal/metric/registry.esm.js

@@ -49,7 +49,7 @@ class MetricRegistryImpl {
   getCounter(key) {
     let value = pipe(this.map, get(key), getOrUndefined);
     if (value == null) {
-      const counter$1 = counter();
+      const counter$1 = counter(key);
       if (!pipe(this.map, has(key))) {
         pipe(this.map, set(key, counter$1));
       }
@@ -71,7 +71,7 @@ class MetricRegistryImpl {
   getGauge(key) {
     let value = pipe(this.map, get(key), getOrUndefined);
     if (value == null) {
-      const gauge$1 = gauge(key, 0);
+      const gauge$1 = gauge(key, key.keyType.bigint ? BigInt(0) : 0);
       if (!pipe(this.map, has(key))) {
         pipe(this.map, set(key, gauge$1));
       }

package/internal/metric/state.esm.js

@@ -144,9 +144,7 @@ class SummaryState {
 }
 
 /** @internal */
-const counter = count => {
-  return new CounterState(count);
-};
+const counter = count => new CounterState(count);
 
 /** @internal */
 const frequency = occurrences => {
@@ -154,9 +152,7 @@ const frequency = occurrences => {
 };
 
 /** @internal */
-const gauge = value => {
-  return new GaugeState(value);
-};
+const gauge = count => new GaugeState(count);
 
 /** @internal */
 const histogram = options => new HistogramState(options.buckets, options.count, options.min, options.max, options.sum);

package/internal/metric.esm.js

@@ -47,7 +47,7 @@ const make = function (keyType, unsafeUpdate, unsafeValue) {
 const mapInput = /*#__PURE__*/dual(2, (self, f) => make(self.keyType, (input, extraTags) => self.unsafeUpdate(f(input), extraTags), self.unsafeValue));
 
 /** @internal */
-const counter = (name, description) => fromMetricKey(counter$1(name, description));
+const counter = (name, options) => fromMetricKey(counter$1(name, options));
 
 /** @internal */
 const frequency = (name, description) => fromMetricKey(frequency$1(name, description));
@@ -65,13 +65,13 @@ const fromMetricKey = key => {
 };
 
 /** @internal */
-const gauge = (name, description) => fromMetricKey(gauge$1(name, description));
+const gauge = (name, options) => fromMetricKey(gauge$1(name, options));
 
 /** @internal */
 const histogram = (name, boundaries, description) => fromMetricKey(histogram$1(name, boundaries, description));
 
 /* @internal */
-const increment = self => update(self, 1);
+const increment = self => update(self, self.keyType.bigint ? BigInt(1) : 1);
 
 /* @internal */
 const incrementBy = /*#__PURE__*/dual(2, (self, amount) => update(self, amount));