effect 2.0.0-next.52 → 2.0.0-next.53

package/internal/core-stream.esm.js

@@ -5,6 +5,7 @@ import { match } from '../Either/dist/effect-Either.esm.js';
 import { dual, identity, constVoid } from '../Function/dist/effect-Function.esm.js';
 import { none } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 import { Continue } from './channel/childExecutorDecision.esm.js';
 import { ContinuationKImpl } from './channel/continuation.esm.js';
 import { PullAfterNext } from './channel/upstreamPullStrategy.esm.js';
@@ -68,7 +69,7 @@ const proto = {
 /** @internal */
 
 /** @internal */
-const isChannel = u => typeof u === "object" && u != null && ChannelTypeId in u || isEffect(u);
+const isChannel = u => hasProperty(u, ChannelTypeId) || isEffect(u);
 
 /** @internal */
 const acquireReleaseOut = /*#__PURE__*/dual(2, (self, release) => {

package/internal/core.esm.js

@@ -21,12 +21,15 @@ import { empty as empty$3 } from '../List/dist/effect-List.esm.js';
 import { make as make$1, get, set } from '../MutableRef/dist/effect-MutableRef.esm.js';
 import { getOrElse, getOrThrow, some, none as none$1, match, isSome } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty, isObject } from '../Predicate/dist/effect-Predicate.esm.js';
 import { reduce as reduce$1, fromIterable as fromIterable$1 } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 import { enable, disable } from '../RuntimeFlagsPatch/dist/effect-RuntimeFlagsPatch.esm.js';
+import { effectVariance } from './Effectable.esm.js';
 
 // -----------------------------------------------------------------------------
 // Effect
 // -----------------------------------------------------------------------------
+
 /** @internal */
 const EffectErrorSymbolKey = "effect/EffectError";
 
@@ -38,7 +41,7 @@ const EffectErrorTypeId = /*#__PURE__*/Symbol.for(EffectErrorSymbolKey);
 /** @internal */
 
 /** @internal */
-const isEffectError = u => typeof u === "object" && u != null && EffectErrorTypeId in u;
+const isEffectError = u => hasProperty(u, EffectErrorTypeId);
 
 /** @internal */
 const makeEffectError = cause => ({
@@ -196,13 +199,6 @@ class EffectPrimitiveSuccess {
   }
 }
 
-/** @internal */
-const effectVariance = {
-  _R: _ => _,
-  _E: _ => _,
-  _A: _ => _
-};
-
 /** @internal */
 
 /** @internal */
@@ -236,7 +232,7 @@ const effectVariance = {
 /** @internal */
 
 /** @internal */
-const isEffect = u => typeof u === "object" && u != null && EffectTypeId in u;
+const isEffect = u => hasProperty(u, EffectTypeId);
 
 /* @internal */
 const withFiberRuntime = withRuntime => {
@@ -368,7 +364,7 @@ const originalSymbol = /*#__PURE__*/Symbol.for("effect/OriginalAnnotation");
 
 /* @internal */
 const originalInstance = obj => {
-  if (typeof obj === "object" && obj !== null && originalSymbol in obj) {
+  if (hasProperty(obj, originalSymbol)) {
     // @ts-expect-error
     return obj[originalSymbol];
   }
@@ -398,7 +394,7 @@ const capture = (obj, span) => {
 };
 
 /* @internal */
-const die = defect => typeof defect === "object" && defect !== null && !(spanSymbol in defect) ? withFiberRuntime(fiber => failCause(die$1(capture(defect, currentSpanFromFiber(fiber))))) : failCause(die$1(defect));
+const die = defect => isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime(fiber => failCause(die$1(capture(defect, currentSpanFromFiber(fiber))))) : failCause(die$1(defect));
 
 /* @internal */
 const dieMessage = message => failCauseSync(() => die$1(RuntimeException(message)));
@@ -419,7 +415,7 @@ const exit = self => matchCause(self, {
 });
 
 /* @internal */
-const fail = error => typeof error === "object" && error !== null && !(spanSymbol in error) ? withFiberRuntime(fiber => failCause(fail$1(capture(error, currentSpanFromFiber(fiber))))) : failCause(fail$1(error));
+const fail = error => isObject(error) && !(spanSymbol in error) ? withFiberRuntime(fiber => failCause(fail$1(capture(error, currentSpanFromFiber(fiber))))) : failCause(fail$1(error));
 
 /* @internal */
 const failSync = evaluate => flatMap(sync(evaluate), fail);
@@ -1016,7 +1012,7 @@ class RequestResolverImpl {
 }
 
 /** @internal */
-const isRequestResolver = u => typeof u === "object" && u != null && RequestResolverTypeId in u;
+const isRequestResolver = u => hasProperty(u, RequestResolverTypeId);
 
 // end
 

package/internal/dataSource.esm.js

@@ -1,8 +1,8 @@
 import { IllegalArgumentException } from '../Cause/dist/effect-Cause.esm.js';
 import { make as make$1, map, empty, appendAll, chunksOf, unsafeFromArray } from '../Chunk/dist/effect-Chunk.esm.js';
-import { forEach, flatMap, exit, never as never$1, race as race$1 } from '../Effect/dist/effect-Effect.esm.js';
+import { forEach, flatMap, exit, matchCauseEffect, never as never$1, race as race$1 } from '../Effect/dist/effect-Effect.esm.js';
 import { dual, pipe } from '../Function/dist/effect-Function.esm.js';
-import { RequestResolverImpl, forEachSequentialDiscard, unit, acquireUseRelease, die, mapInputContext as mapInputContext$1, forEachSequential, exitSucceed } from './core.esm.js';
+import { RequestResolverImpl, forEachSequentialDiscard, unit, acquireUseRelease, die, mapInputContext as mapInputContext$1, forEachSequential, exitSucceed, exitFail } from './core.esm.js';
 import { invokeWithInterrupt, zipWithOptions } from './fiberRuntime.esm.js';
 import { complete } from './request.esm.js';
 import { reduce, partitionMap } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
@@ -44,10 +44,35 @@ const fromFunctionBatched = f => makeBatched(as => forEach(f(as), (res, i) => co
 })).identified("FromFunctionBatched", f);
 
 /** @internal */
-const fromFunctionEffect = f => makeBatched(requests => forEach(requests, a => flatMap(exit(f(a)), e => complete(a, e)), {
+const fromEffect = f => makeBatched(requests => forEach(requests, a => flatMap(exit(f(a)), e => complete(a, e)), {
   concurrency: "unbounded",
   discard: true
-})).identified("FromFunctionEffect", f);
+})).identified("FromEffect", f);
+
+/** @internal */
+const fromEffectTagged = () => fns => makeBatched(requests => {
+  const grouped = {};
+  const tags = [];
+  for (let i = 0, len = requests.length; i < len; i++) {
+    if (tags.includes(requests[i]._tag)) {
+      grouped[requests[i]._tag].push(requests[i]);
+    } else {
+      grouped[requests[i]._tag] = [requests[i]];
+      tags.push(requests[i]._tag);
+    }
+  }
+  return forEach(tags, tag => matchCauseEffect(fns[tag](grouped[tag]), {
+    onFailure: cause => forEach(grouped[tag], req => complete(req, exitFail(cause)), {
+      discard: true
+    }),
+    onSuccess: res => forEach(grouped[tag], (req, i) => complete(req, exitSucceed(res[i])), {
+      discard: true
+    })
+  }), {
+    concurrency: "unbounded",
+    discard: true
+  });
+}).identified("FromEffectTagged", fns);
 
 /** @internal */
 const never = /*#__PURE__*/make(() => never$1).identified("Never");
@@ -58,4 +83,4 @@ const provideContext = /*#__PURE__*/dual(2, (self, context) => mapInputContext(s
 /** @internal */
 const race = /*#__PURE__*/dual(2, (self, that) => new RequestResolverImpl(requests => race$1(self.runAll(requests), that.runAll(requests))).identified("Race", self, that));
 
-export { around, batchN, eitherWith, fromFunction, fromFunctionBatched, fromFunctionEffect, make, makeBatched, makeWithEntry, mapInputContext, never, provideContext, race };
+export { around, batchN, eitherWith, fromEffect, fromEffectTagged, fromFunction, fromFunctionBatched, make, makeBatched, makeWithEntry, mapInputContext, never, provideContext, race };

package/internal/effect/circular.esm.js

@@ -18,7 +18,7 @@ import { track } from '../supervisor.esm.js';
 import { get, set as set$1, empty } from '../../MutableHashMap/dist/effect-MutableHashMap.esm.js';
 import { isNone, some, none, flatMap as flatMap$1, map as map$1 } from '../../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
-import { isIterable } from '../../Predicate/dist/effect-Predicate.esm.js';
+import { isIterable, hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 import { currentScheduler } from '../../Scheduler/dist/effect-Scheduler.esm.js';
 
 /** @internal */
@@ -137,7 +137,7 @@ class Key {
     this.eq = eq;
   }
   [symbol](that) {
-    if (typeof that === "object" && that !== null && memoKeySymbol in that) {
+    if (hasProperty(that, memoKeySymbol)) {
       if (this.eq) {
         return this.eq(this.a, that.a);
       } else {

package/internal/fiber.esm.js

@@ -12,6 +12,7 @@ import { Order as Order$1 } from '../Number/dist/effect-Number.esm.js';
 import { some, none as none$1, fromNullable } from '../Option/dist/effect-Option.esm.js';
 import { mapInput, tuple } from '../Order/dist/effect-Order.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const FiberSymbolKey = "effect/Fiber";
@@ -43,7 +44,7 @@ const RuntimeFiberTypeId = /*#__PURE__*/Symbol.for(RuntimeFiberSymbolKey);
 const Order = /*#__PURE__*/pipe( /*#__PURE__*/tuple(Order$1, Order$1), /*#__PURE__*/mapInput(fiber => [fiber.id().startTimeMillis, fiber.id().id]));
 
 /** @internal */
-const isFiber = u => typeof u === "object" && u != null && FiberTypeId in u;
+const isFiber = u => hasProperty(u, FiberTypeId);
 
 /** @internal */
 const isRuntimeFiber = self => RuntimeFiberTypeId in self;

package/internal/fiberId.esm.js

@@ -6,6 +6,7 @@ import { every, reduce, union, make as make$1, empty, size } from '../HashSet/di
 import { toString, NodeInspectSymbol, toJSON } from '../Inspectable/dist/effect-Inspectable.esm.js';
 import { get, set, make as make$2 } from '../MutableRef/dist/effect-MutableRef.esm.js';
 import { none as none$1, some } from '../Option/dist/effect-Option.esm.js';
+import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const FiberIdSymbolKey = "effect/FiberId";
@@ -126,9 +127,7 @@ const composite = (left, right) => {
 };
 
 /** @internal */
-const isFiberId = self => {
-  return typeof self === "object" && self != null && FiberIdTypeId in self;
-};
+const isFiberId = self => hasProperty(self, FiberIdTypeId);
 
 /** @internal */
 const isNone = self => {

package/internal/fiberRuntime.esm.js

@@ -2,6 +2,7 @@ import { not } from '../Boolean/dist/effect-Boolean.esm.js';
 import { fromIterable as fromIterable$1, isNonEmpty, headNonEmpty, tailNonEmpty, unsafeFromArray, prepend } from '../Chunk/dist/effect-Chunk.esm.js';
 import { getOption, get as get$1, add, Tag, merge, make as make$2, unsafeGet } from '../Context/dist/effect-Context.esm.js';
 import { await as _await$1 } from '../Deferred/dist/effect-Deferred.esm.js';
+import { EffectTypeId } from '../Effectable/dist/effect-Effectable.esm.js';
 import { parallel, sequential, parallelN } from '../ExecutionStrategy/dist/effect-ExecutionStrategy.esm.js';
 import { threadName, combine, none as none$2, unsafeMake as unsafeMake$1 } from '../FiberId/dist/effect-FiberId.esm.js';
 import { getOrDefault } from '../FiberRefs/dist/effect-FiberRefs.esm.js';
@@ -17,7 +18,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, currentContext, fiberRefUnsafeMakeHashSet, uninterruptible, tap, isEffect, withFiberRuntime, fiberRefLocally, currentForkScopeOverride, map as map$2, 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, 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, currentContext, fiberRefUnsafeMakeHashSet, uninterruptible, tap, isEffect, withFiberRuntime, fiberRefLocally, currentForkScopeOverride, map as map$2, 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, blocked, catchAllCause, runRequestBlock, RevertFlags, yieldNow as yieldNow$1, dieMessage, isEffectError, withRuntimeFlags, matchEffect, if_, zipWith, currentRequestBatching, transplant, step, deferredUnsafeDone, deferredFail, exitCollectAll, exitIsFailure, exitInterrupt, exitAsUnit, interruptAsFiber, flatMapStep } from './core.esm.js';
 import { makeSpan, currentTimeNanosTracing, provideService, mapErrorCause } from './core-effect.esm.js';
 import { currentServices } from './defaultServices.esm.js';
 import { consoleTag } from './defaultServices/console.esm.js';
@@ -45,6 +46,7 @@ import { fromIterable, filterMap, reduce, flatten as flatten$1, reduceRight, com
 import { make as make$1, modify, update, get as get$2 } from '../Ref/dist/effect-Ref.esm.js';
 import { empty, exclude } from '../RuntimeFlagsPatch/dist/effect-RuntimeFlagsPatch.esm.js';
 import { currentScheduler } from '../Scheduler/dist/effect-Scheduler.esm.js';
+import { moduleVersion } from './version.esm.js';
 
 /** @internal */
 const fiberStarted = /*#__PURE__*/counter("effect_fiber_started");
@@ -1103,20 +1105,20 @@ class FiberRuntime {
         }
       }
       try {
-        if (!("_op" in cur)) {
+        if (!("_op" in cur) || !(cur._op in this)) {
           console.log(cur);
-        }
-        if (!(cur._op in this)) {
-          if (typeof cur === "function") {
-            console.log(cur());
-          }
           // @ts-expect-error
           absurd(cur);
         }
+
         // @ts-expect-error
-        cur = this._tracer.context(
-        // @ts-expect-error
-        () => this[cur._op](cur), this);
+        cur = this._tracer.context(() => {
+          if (moduleVersion !== cur[EffectTypeId]._V) {
+            return dieMessage(`Cannot execute an Effect versioned ${cur[EffectTypeId]._V} with a Runtime of version ${moduleVersion}`);
+          }
+          // @ts-expect-error
+          return this[cur._op](cur);
+        }, this);
       } catch (e) {
         if (isEffect(e)) {
           if (e._op === OP_YIELD || e._op === OP_ASYNC) {

package/internal/fiberStatus.esm.js

@@ -1,6 +1,7 @@
 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';
+import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 
 const FiberStatusSymbolKey = "effect/FiberStatus";
 
@@ -75,7 +76,7 @@ const running = runtimeFlags => new Running(runtimeFlags);
 const suspended = (runtimeFlags, blockingOn) => new Suspended(runtimeFlags, blockingOn);
 
 /** @internal */
-const isFiberStatus = u => typeof u === "object" && u != null && FiberStatusTypeId in u;
+const isFiberStatus = u => hasProperty(u, FiberStatusTypeId);
 
 /** @internal */
 const isDone = self => self._tag === OP_DONE;

package/internal/groupBy.esm.js

@@ -6,6 +6,7 @@ import { succeed as succeed$2, map as map$4 } from '../Exit/dist/effect-Exit.esm
 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 { hasProperty } from '../Predicate/dist/effect-Predicate.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';
@@ -29,7 +30,7 @@ const groupByVariance = {
 };
 
 /** @internal */
-const isGroupBy = u => typeof u === "object" && u != null && GroupByTypeId in u;
+const isGroupBy = u => hasProperty(u, GroupByTypeId);
 
 /** @internal */
 const evaluate = /*#__PURE__*/dual(args => isGroupBy(args[0]), (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue(queue, {

package/internal/layer.esm.js

@@ -1,6 +1,6 @@
 import { die as die$1, fail as fail$1, failureOrCause } from '../Cause/dist/effect-Cause.esm.js';
 import { sleep, currentTimeMillis } from '../Clock/dist/effect-Clock.esm.js';
-import { empty, get, make, merge as merge$1, unsafeGet, Tag, isContext, isTag } from '../Context/dist/effect-Context.esm.js';
+import { empty, get, isTag, make, merge as merge$1, unsafeGet, Tag, isContext } from '../Context/dist/effect-Context.esm.js';
 import { millis } from '../Duration/dist/effect-Duration.esm.js';
 import { diff as diff$1 } from '../FiberRefsPatch/dist/effect-FiberRefsPatch.esm.js';
 import { dual, pipe } from '../Function/dist/effect-Function.esm.js';
@@ -14,6 +14,7 @@ import { make as make$1, set, modify, update, get as get$1 } from './ref.esm.js'
 import { runtime, defaultRuntime } from './runtime.esm.js';
 import { modifyEffect } from './synchronizedRef.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 import { isDone } from '../ScheduleDecision/dist/effect-ScheduleDecision.esm.js';
 import { start } from '../ScheduleIntervals/dist/effect-ScheduleIntervals.esm.js';
 import { Scope } from '../Scope/dist/effect-Scope.esm.js';
@@ -66,9 +67,7 @@ const proto = {
 /** @internal */
 
 /** @internal */
-const isLayer = u => {
-  return typeof u === "object" && u != null && LayerTypeId in u;
-};
+const isLayer = u => hasProperty(u, LayerTypeId);
 
 /** @internal */
 const isFresh = self => {

package/internal/metric/boundaries.esm.js

@@ -3,6 +3,7 @@ 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';
 import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 import { makeBy } from '../../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 /** @internal */
@@ -29,9 +30,7 @@ class MetricBoundariesImpl {
 }
 
 /** @internal */
-const isMetricBoundaries = u => {
-  return typeof u === "object" && u != null && MetricBoundariesTypeId in u;
-};
+const isMetricBoundaries = u => hasProperty(u, MetricBoundariesTypeId);
 
 /** @internal */
 const fromChunk = chunk => {

package/internal/metric/key.esm.js

@@ -6,6 +6,7 @@ import { counter as counter$1, frequency as frequency$1, gauge as gauge$1, histo
 import { make as make$1 } from './label.esm.js';
 import { fromNullable } from '../../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const MetricKeySymbolKey = "effect/MetricKey";
@@ -39,7 +40,7 @@ class MetricKeyImpl {
 }
 
 /** @internal */
-const isMetricKey = u => typeof u === "object" && u != null && MetricKeyTypeId in u;
+const isMetricKey = u => hasProperty(u, MetricKeyTypeId);
 
 /** @internal */
 const counter = (name, options) => new MetricKeyImpl(name, counter$1(options), fromNullable(options?.description));

package/internal/metric/keyType.esm.js

@@ -3,6 +3,7 @@ import { symbol as symbol$1, equals } from '../../Equal/dist/effect-Equal.esm.js
 import { pipe } from '../../Function/dist/effect-Function.esm.js';
 import { symbol, hash, combine } from '../../Hash/dist/effect-Hash.esm.js';
 import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const MetricKeyTypeSymbolKey = "effect/MetricKeyType";
@@ -178,48 +179,36 @@ const summary = options => {
  * @since 2.0.0
  * @category refinements
  */
-const isMetricKeyType = u => {
-  return typeof u === "object" && u != null && MetricKeyTypeTypeId in u;
-};
+const isMetricKeyType = u => hasProperty(u, MetricKeyTypeTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isCounterKey = u => {
-  return typeof u === "object" && u != null && CounterKeyTypeTypeId in u;
-};
+const isCounterKey = u => hasProperty(u, CounterKeyTypeTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isFrequencyKey = u => {
-  return typeof u === "object" && u != null && FrequencyKeyTypeTypeId in u;
-};
+const isFrequencyKey = u => hasProperty(u, FrequencyKeyTypeTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isGaugeKey = u => {
-  return typeof u === "object" && u != null && GaugeKeyTypeTypeId in u;
-};
+const isGaugeKey = u => hasProperty(u, GaugeKeyTypeTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isHistogramKey = u => {
-  return typeof u === "object" && u != null && HistogramKeyTypeTypeId in u;
-};
+const isHistogramKey = u => hasProperty(u, HistogramKeyTypeTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isSummaryKey = u => {
-  return typeof u === "object" && u != null && SummaryKeyTypeTypeId in u;
-};
+const isSummaryKey = u => hasProperty(u, SummaryKeyTypeTypeId);
 
 export { CounterKeyTypeTypeId, FrequencyKeyTypeTypeId, GaugeKeyTypeTypeId, HistogramKeyType, HistogramKeyTypeTypeId, MetricKeyTypeTypeId, SummaryKeyTypeTypeId, counter, frequency, gauge, histogram, isCounterKey, isFrequencyKey, isGaugeKey, isHistogramKey, isMetricKeyType, isSummaryKey, summary };

package/internal/metric/label.esm.js

@@ -2,6 +2,7 @@ import { symbol as symbol$1 } 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';
 import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const MetricLabelSymbolKey = "effect/MetricLabel";
@@ -33,8 +34,6 @@ const make = (key, value) => {
 };
 
 /** @internal */
-const isMetricLabel = u => {
-  return typeof u === "object" && u != null && MetricLabelTypeId in u;
-};
+const isMetricLabel = u => hasProperty(u, MetricLabelTypeId);
 
 export { MetricLabelTypeId, isMetricLabel, make };

package/internal/metric/state.esm.js

@@ -2,6 +2,7 @@ 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';
 import { pipeArguments } from '../../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const MetricStateSymbolKey = "effect/MetricState";
@@ -161,45 +162,33 @@ const histogram = options => new HistogramState(options.buckets, options.count,
 const summary = options => new SummaryState(options.error, options.quantiles, options.count, options.min, options.max, options.sum);
 
 /** @internal */
-const isMetricState = u => {
-  return typeof u === "object" && u != null && MetricStateTypeId in u;
-};
+const isMetricState = u => hasProperty(u, MetricStateTypeId);
 
 /** @internal */
-const isCounterState = u => {
-  return typeof u === "object" && u != null && CounterStateTypeId in u;
-};
+const isCounterState = u => hasProperty(u, CounterStateTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isFrequencyState = u => {
-  return typeof u === "object" && u != null && FrequencyStateTypeId in u;
-};
+const isFrequencyState = u => hasProperty(u, FrequencyStateTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isGaugeState = u => {
-  return typeof u === "object" && u != null && GaugeStateTypeId in u;
-};
+const isGaugeState = u => hasProperty(u, GaugeStateTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isHistogramState = u => {
-  return typeof u === "object" && u != null && HistogramStateTypeId in u;
-};
+const isHistogramState = u => hasProperty(u, HistogramStateTypeId);
 
 /**
  * @since 2.0.0
  * @category refinements
  */
-const isSummaryState = u => {
-  return typeof u === "object" && u != null && SummaryStateTypeId in u;
-};
+const isSummaryState = u => hasProperty(u, SummaryStateTypeId);
 
 export { CounterStateTypeId, FrequencyStateTypeId, GaugeStateTypeId, HistogramState, HistogramStateTypeId, MetricStateTypeId, SummaryState, SummaryStateTypeId, counter, frequency, gauge, histogram, isCounterState, isFrequencyState, isGaugeState, isHistogramState, isMetricState, isSummaryState, summary };

package/internal/pool.esm.js

@@ -10,6 +10,7 @@ import { forkDaemon, addFinalizer, all, disconnect, withEarlyRelease, acquireRel
 import { bounded, offer, take, awaitShutdown, shutdown as shutdown$1 } from './queue.esm.js';
 import { make as make$1, set, get as get$1, update, modify } from './ref.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 
 /** @internal */
 const PoolSymbolKey = "effect/Pool";
@@ -244,7 +245,7 @@ const makeWith = options => uninterruptibleMask(restore => pipe(all([context(),
 })));
 
 /** @internal */
-const isPool = u => typeof u === "object" && u != null && PoolTypeId in u;
+const isPool = u => hasProperty(u, PoolTypeId);
 
 /** @internal */
 const make = options => makeWith({

package/internal/queue.esm.js

@@ -6,6 +6,7 @@ import { bounded as bounded$1, unbounded as unbounded$1, length, isEmpty as isEm
 import { make as make$1, 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 { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 import { fromIterable, empty, splitAt } from '../ReadonlyArray/dist/effect-ReadonlyArray.esm.js';
 
 /** @internal */
@@ -232,10 +233,10 @@ const takeRemainderLoop = (self, min, max, acc) => {
 const isQueue = u => isEnqueue(u) && isDequeue(u);
 
 /** @internal */
-const isEnqueue = u => typeof u === "object" && u != null && EnqueueTypeId in u;
+const isEnqueue = u => hasProperty(u, EnqueueTypeId);
 
 /** @internal */
-const isDequeue = u => typeof u === "object" && u != null && DequeueTypeId in u;
+const isDequeue = u => hasProperty(u, DequeueTypeId);
 
 /** @internal */
 const bounded = requestedCapacity => pipe(sync(() => bounded$1(requestedCapacity)), flatMap(queue => make(backingQueueFromMutableQueue(queue), backPressureStrategy())));

package/internal/request.esm.js

@@ -1,6 +1,7 @@
 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 { hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 import { struct } from './Data.esm.js';
 
 /** @internal */
@@ -16,7 +17,7 @@ const requestVariance = {
 };
 
 /** @internal */
-const isRequest = u => typeof u === "object" && u != null && RequestTypeId in u;
+const isRequest = u => hasProperty(u, RequestTypeId);
 
 /** @internal */
 const of = () => args =>

package/internal/runtime.esm.js

@@ -5,7 +5,7 @@ import { unsafeMake, none as none$2 } from '../FiberId/dist/effect-FiberId.esm.j
 import { updatedAs, forkAs, empty as empty$1 } from '../FiberRefs/dist/effect-FiberRefs.esm.js';
 import { pipe } from '../Function/dist/effect-Function.esm.js';
 import { toString, NodeInspectSymbol } from '../Inspectable/dist/effect-Inspectable.esm.js';
-import { prettyErrors, NoSuchElementException } from './cause.esm.js';
+import { prettyErrors, pretty, NoSuchElementException } from './cause.esm.js';
 import { currentContext, withFiberRuntime, flatMap, deferredMake, uninterruptibleMask, zipRight, catchAllCause, intoDeferred, deferredFailCause, deferredAwait, exitFail, exitSucceed, succeed } from './core.esm.js';
 import { FiberRuntime, fork } from './fiberRuntime.esm.js';
 import { globalScope } from './fiberScope.esm.js';
@@ -14,7 +14,7 @@ import { make as make$1, RuntimeMetrics, CooperativeYielding, Interruption } fro
 import { none } from './supervisor.esm.js';
 import { none as none$1 } 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';
+import { isTagged, hasProperty } from '../Predicate/dist/effect-Predicate.esm.js';
 import { currentScheduler, SyncScheduler } from '../Scheduler/dist/effect-Scheduler.esm.js';
 
 /** @internal */
@@ -123,7 +123,7 @@ const fiberFailure = cause => {
     const head = prettyErrors$1[0];
     error.name = head.message.split(":")[0];
     error.message = head.message.substring(error.name.length + 2);
-    error.stack = `${error.name}: ${error.message}\n${head.stack}`;
+    error.stack = pretty(cause);
   }
   error[FiberFailureId] = FiberFailureId;
   error[FiberFailureCauseId] = cause;
@@ -143,7 +143,7 @@ const fiberFailure = cause => {
 };
 
 /** @internal */
-const isFiberFailure = u => typeof u === "object" && u !== null && FiberFailureId in u;
+const isFiberFailure = u => hasProperty(u, FiberFailureId);
 const fastPath = effect => {
   const op = effect;
   switch (op._op) {

package/internal/sink.esm.js

@@ -10,6 +10,7 @@ import { empty as empty$1, has, unsafeGet, set } from '../HashMap/dist/effect-Ha
 import { empty as empty$2, has as has$1, add } from '../HashSet/dist/effect-HashSet.esm.js';
 import { some as some$1, none, match, isNone, orElse as orElse$2 } from '../Option/dist/effect-Option.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+import { hasProperty } from '../Predicate/dist/effect-Predicate.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';
@@ -42,7 +43,7 @@ class SinkImpl {
 }
 
 /** @internal */
-const isSink = u => typeof u === "object" && u != null && SinkTypeId in u;
+const isSink = u => hasProperty(u, SinkTypeId);
 
 /** @internal */
 const suspend = evaluate => new SinkImpl(suspend$1(() => toChannel(evaluate())));