effect 2.0.0-next.47 → 2.0.0-next.49

package/dist/{tRef-90f0872b.cjs.dev.js → tRef-44d17d07.cjs.dev.js}

@@ -1,7 +1,7 @@
 'use strict';
 
 var Function_dist_effectFunction = require('../Function/dist/effect-Function.cjs.dev.js');
-var core = require('./core-c01fd1d8.cjs.dev.js');
+var core = require('./core-e6f9fdbe.cjs.dev.js');
 var Option_dist_effectOption = require('../Option/dist/effect-Option.cjs.dev.js');
 
 /** @internal */

package/internal/cause.esm.js

@@ -67,7 +67,8 @@ const proto = {
         return {
           _id: "Cause",
           _tag: this._tag,
-          errors: toJSON(prettyErrors(this))
+          left: toJSON(this.left),
+          right: toJSON(this.right)
         };
     }
   },

package/internal/channel.esm.js

@@ -1,25 +1,25 @@
-import { failureOrCause, map as map$2, isInterrupted, die, isDieType } from '../Cause/dist/effect-Cause.esm.js';
-import { fromIterable, unsafeGet as unsafeGet$1, empty, isEmpty, unsafeFromArray } from '../Chunk/dist/effect-Chunk.esm.js';
+import { failureOrCause, map as map$2, die, isDieType, isInterrupted } from '../Cause/dist/effect-Cause.esm.js';
+import { empty, isEmpty, unsafeFromArray, fromIterable, unsafeGet as unsafeGet$1 } from '../Chunk/dist/effect-Chunk.esm.js';
 import { add, merge as merge$1, make as make$4, unsafeGet } from '../Context/dist/effect-Context.esm.js';
 import { await as _await, make as make$1, succeed as succeed$2, failCause as failCause$2, isDone } from '../Deferred/dist/effect-Deferred.esm.js';
-import { unit, flatMap as flatMap$1, uninterruptible, tap, context as context$1, map as map$1, suspend as suspend$1, matchCause, flatten as flatten$1, gen, acquireRelease, makeSemaphore, matchCauseEffect, failCause as failCause$1, zipRight as zipRight$1, interruptible, asUnit as asUnit$1, succeed as succeed$1, uninterruptibleMask, exit, raceFirst, tapErrorCause, intoDeferred, forkScoped, forever, raceWith, as as as$1, race, scoped as scoped$1, when, repeatWhile, zip as zip$1, zipWith, forkDaemon, never as never$1, sync as sync$1, withSpanScoped, repeatUntil, catchAllCause as catchAllCause$1 } from '../Effect/dist/effect-Effect.esm.js';
+import { unit, flatMap as flatMap$1, uninterruptible, tap, context as context$1, map as map$1, suspend as suspend$1, matchCause, flatten as flatten$1, gen, acquireRelease, makeSemaphore, matchCauseEffect, failCause as failCause$1, zipRight as zipRight$1, interruptible, asUnit as asUnit$1, succeed as succeed$1, uninterruptibleMask, exit, raceFirst, tapErrorCause, intoDeferred, forkScoped, forever, raceWith, as as as$1, race, scoped as scoped$1, when, repeatWhile, zip as zip$1, zipWith, forkDaemon, never as never$1, sync as sync$1, setSpan, repeatUntil, catchAllCause as catchAllCause$1 } from '../Effect/dist/effect-Effect.esm.js';
 import { match, left, right } from '../Either/dist/effect-Either.esm.js';
 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 { match as match$2, failCause as failCause$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 { 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, get, set, modify, update } from '../Ref/dist/effect-Ref.esm.js';
 import { make as make$3, extend, close } from '../Scope/dist/effect-Scope.esm.js';
 import { runScoped, run as run$1, ChannelExecutor, readUpstream } from './channel/channelExecutor.esm.js';
 import { Done, Await } from './channel/mergeDecision.esm.js';
 import { BothRunning, RightDone, LeftDone } from './channel/mergeState.esm.js';
-import { match as match$2, BackPressure } from './channel/mergeStrategy.esm.js';
+import { match as match$3, BackPressure } from './channel/mergeStrategy.esm.js';
 import { make as make$2 } from './channel/singleProducerAsyncInput.esm.js';
-import { flatMap, fromEffect, ensuringWith, suspend, catchAllCause, failCause, concatMapWith, readWith, write, fail, succeedNow, pipeTo, concatAll, readWithCause, succeed, foldCauseChannel, sync, embedInput, provideContext, readOrFail, collectElements, acquireReleaseOut, concatAllWith, unit as unit$1, isChannel } from './core-stream.esm.js';
+import { flatMap, fromEffect, ensuringWith, suspend, catchAllCause, failCause, concatMapWith, readWith, write, fail, succeedNow, pipeTo, concatAll, succeed, sync, readWithCause, foldCauseChannel, embedInput, provideContext, readOrFail, collectElements, acquireReleaseOut, concatAllWith, unit as unit$1, isChannel } from './core-stream.esm.js';
 import { OP_DONE as OP_DONE$1 } from './opCodes/channelMergeDecision.esm.js';
 import { OP_RIGHT_DONE, OP_LEFT_DONE, OP_BOTH_RUNNING } from './opCodes/channelMergeState.esm.js';
 import { OP_READ, OP_FROM_EFFECT, OP_EMIT, OP_DONE } from './opCodes/channelState.esm.js';
@@ -225,7 +225,7 @@ const fromQueue = queue => suspend(() => fromQueueInternal(queue));
 
 /** @internal */
 const fromQueueInternal = queue => pipe(fromEffect(take(queue)), flatMap(match({
-  onLeft: match$3({
+  onLeft: match$2({
     onFailure: failCause,
     onSuccess: succeedNow
   }),
@@ -338,38 +338,36 @@ const mergeAllWith = ({
   concurrency,
   mergeStrategy = BackPressure()
 }) => (channels, f) => pipe(gen(function* ($) {
+  const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : concurrency;
   const input = yield* $(make$2());
   const queueReader = fromInput(input);
   const queue = yield* $(acquireRelease(bounded(bufferSize), queue => shutdown(queue)));
   const cancelers = yield* $(acquireRelease(unbounded(), queue => shutdown(queue)));
   const lastDone = yield* $(make(none()));
   const errorSignal = yield* $(make$1());
-  const withPermits = concurrency === "unbounded" ? _ => identity : (yield* $(makeSemaphore(concurrency))).withPermits;
+  const withPermits = (yield* $(makeSemaphore(concurrencyN))).withPermits;
   const pull = yield* $(toPull(channels));
   const evaluatePull = pull => pipe(flatMap$1(pull, match({
     onLeft: done => succeed$1(some(done)),
     onRight: outElem => as$1(offer(queue, succeed$1(right(outElem))), none())
-  })), repeatUntil(isSome), flatMap$1(match$1({
-    onNone: () => unit,
-    onSome: outDone => update(lastDone, match$1({
-      onNone: () => some(outDone),
-      onSome: lastDone => some(f(lastDone, outDone))
-    }))
-  })), catchAllCause$1(cause => isInterrupted(cause) ? failCause$1(cause) : pipe(offer(queue, failCause$1(cause)), zipRight$1(succeed$2(errorSignal, void 0)), asUnit$1)));
+  })), repeatUntil(isSome), flatMap$1(outDone => update(lastDone, match$1({
+    onNone: () => some(outDone.value),
+    onSome: lastDone => some(f(lastDone, outDone.value))
+  }))), catchAllCause$1(cause => isInterrupted(cause) ? failCause$1(cause) : pipe(offer(queue, failCause$1(cause)), zipRight$1(succeed$2(errorSignal, void 0)), asUnit$1)));
   yield* $(matchCauseEffect(pull, {
     onFailure: cause => pipe(offer(queue, failCause$1(cause)), zipRight$1(succeed$1(false))),
     onSuccess: match({
-      onLeft: outDone => raceWith(_await(errorSignal), withPermits(concurrency)(unit), {
-        onSelfDone: (_, permitAcquisition) => pipe(interrupt(permitAcquisition), as$1(false)),
-        onOtherDone: (_, failureAwait) => pipe(interrupt(failureAwait), zipRight$1(pipe(get(lastDone), flatMap$1(match$1({
+      onLeft: outDone => raceWith(_await(errorSignal), withPermits(concurrencyN)(unit), {
+        onSelfDone: (_, permitAcquisition) => as$1(interrupt(permitAcquisition), false),
+        onOtherDone: (_, failureAwait) => zipRight$1(interrupt(failureAwait), pipe(get(lastDone), flatMap$1(match$1({
           onNone: () => offer(queue, succeed$1(left(outDone))),
           onSome: lastDone => offer(queue, succeed$1(left(f(lastDone, outDone))))
-        })), as$1(false))))
+        })), as$1(false)))
       }),
-      onRight: channel => pipe(mergeStrategy, match$2({
+      onRight: channel => match$3(mergeStrategy, {
         onBackPressure: () => gen(function* ($) {
           const latch = yield* $(make$1());
-          const raceEffects = pipe(queueReader, pipeTo(channel), toPull, flatMap$1(pull => pipe(evaluatePull(pull), race(_await(errorSignal)))), scoped$1);
+          const raceEffects = pipe(queueReader, pipeTo(channel), toPull, flatMap$1(pull => race(evaluatePull(pull), _await(errorSignal))), scoped$1);
           yield* $(succeed$2(latch, void 0), zipRight$1(raceEffects), withPermits(1), forkScoped);
           yield* $(_await(latch));
           const errored = yield* $(isDone(errorSignal));
@@ -379,7 +377,7 @@ const mergeAllWith = ({
           const canceler = yield* $(make$1());
           const latch = yield* $(make$1());
           const size$1 = yield* $(size(cancelers));
-          yield* $(take(cancelers), flatMap$1(_ => succeed$2(_, void 0)), when(() => concurrency === "unbounded" ? false : size$1 >= concurrency));
+          yield* $(take(cancelers), flatMap$1(_ => succeed$2(_, void 0)), when(() => size$1 >= concurrencyN));
           yield* $(offer(cancelers, canceler));
           const raceEffects = pipe(queueReader, pipeTo(channel), toPull, flatMap$1(pull => pipe(evaluatePull(pull), race(_await(errorSignal)), race(_await(canceler)))), scoped$1);
           yield* $(succeed$2(latch, void 0), zipRight$1(raceEffects), withPermits(1), forkScoped);
@@ -387,7 +385,7 @@ const mergeAllWith = ({
           const errored = yield* $(isDone(errorSignal));
           return !errored;
         })
-      }))
+      })
     })
   }), repeatWhile(identity), forkScoped);
   return [queue, input];
@@ -425,7 +423,7 @@ const mergeWith = /*#__PURE__*/dual(2, (self, options) => unwrapScoped(flatMap$1
         if (op._tag === OP_DONE$1) {
           return succeed$1(fromEffect(zipRight$1(interrupt(fiber), op.effect)));
         }
-        return map$1(_await$1(fiber), match$3({
+        return map$1(_await$1(fiber), match$2({
           onFailure: cause => fromEffect(op.f(failCause$3(cause))),
           onSuccess: match({
             onLeft: done => fromEffect(op.f(succeed$3(done))),
@@ -433,7 +431,7 @@ const mergeWith = /*#__PURE__*/dual(2, (self, options) => unwrapScoped(flatMap$1
           })
         }));
       };
-      return match$3(exit, {
+      return match$2(exit, {
         onFailure: cause => onDecision(done(failCause$3(cause))),
         onSuccess: match({
           onLeft: z => onDecision(done(succeed$3(z))),
@@ -454,7 +452,7 @@ const mergeWith = /*#__PURE__*/dual(2, (self, options) => unwrapScoped(flatMap$1
           }
         case OP_LEFT_DONE:
           {
-            return unwrap(map$1(exit(pullR), match$3({
+            return unwrap(map$1(exit(pullR), match$2({
               onFailure: cause => fromEffect(state.f(failCause$3(cause))),
               onSuccess: match({
                 onLeft: done => fromEffect(state.f(succeed$3(done))),
@@ -464,7 +462,7 @@ const mergeWith = /*#__PURE__*/dual(2, (self, options) => unwrapScoped(flatMap$1
           }
         case OP_RIGHT_DONE:
           {
-            return unwrap(map$1(exit(pullL), match$3({
+            return unwrap(map$1(exit(pullL), match$2({
               onFailure: cause => fromEffect(state.f(failCause$3(cause))),
               onSuccess: match({
                 onLeft: done => fromEffect(state.f(succeed$3(done))),
@@ -560,7 +558,7 @@ const interpretToPull = (channelState, exec) => {
   switch (state._tag) {
     case OP_DONE:
       {
-        return match$3(exec.getDone(), {
+        return match$2(exec.getDone(), {
           onFailure: failCause$1,
           onSuccess: done => succeed$1(left(done))
         });
@@ -602,7 +600,7 @@ const unwrapScoped = self => concatAllWith(scoped(self), (d, _) => d, (d, _) =>
 const updateService = /*#__PURE__*/dual(3, (self, tag, f) => mapInputContext(self, context => merge$1(context, make$4(tag, f(unsafeGet(context, tag))))));
 
 /** @internal */
-const withSpan = /*#__PURE__*/dual(3, (self, name, options) => unwrapScoped(as$1(withSpanScoped(name, options), self)));
+const withSpan = /*#__PURE__*/dual(3, (self, name, options) => unwrapScoped(as$1(setSpan(name, options), self)));
 
 /** @internal */
 const writeAll = (...outs) => writeChunk(fromIterable(outs));

package/internal/core-effect.esm.js

@@ -839,7 +839,7 @@ const linkSpans = /*#__PURE__*/dual(args => isEffect(args[0]), (self, span, attr
 /** @internal */
 const makeSpan = (name, options) => tracerWith(tracer => flatMap(options?.parent ? succeedSome(options.parent) : options?.root ? succeedNone : currentParentSpan, parent => flatMap(fiberRefGet(currentTracerSpanAnnotations), annotations => flatMap(fiberRefGet(currentTracerSpanLinks), links => flatMap(currentTimeNanosTracing, startTime => sync(() => {
   const linksArray = options?.links ? [...toReadonlyArray(links), ...options.links] : toReadonlyArray(links);
-  const span = tracer.span(name, parent, options?.context ?? empty$1(), linksArray, startTime);
+  const span = tracer.span(name, parent, options?.context ?? empty$1(), linksArray, options?.sampled ?? (parent._tag === "Some" ? parent.value.sampled : true), startTime);
   forEach(annotations, (value, key) => span.attribute(key, value));
   Object.entries(options?.attributes ?? {}).forEach(([k, v]) => span.attribute(k, v));
   return span;

package/internal/core-stream.esm.js

@@ -8,7 +8,7 @@ import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
 import { Continue } from './channel/childExecutorDecision.esm.js';
 import { ContinuationKImpl } from './channel/continuation.esm.js';
 import { PullAfterNext } from './channel/upstreamPullStrategy.esm.js';
-import { OP_BRACKET_OUT, OP_FOLD, OP_CONCAT_ALL, OP_BRIDGE, OP_ENSURING, OP_FAIL, OP_FROM_EFFECT, OP_PIPE_TO, OP_PROVIDE, OP_READ, OP_SUCCEED, OP_EMIT, OP_SUCCEED_NOW, OP_SUSPEND } from './opCodes/channel.esm.js';
+import { OP_BRACKET_OUT, OP_FOLD, OP_CONCAT_ALL, OP_BRIDGE, OP_ENSURING, OP_FAIL, OP_FROM_EFFECT, OP_PIPE_TO, OP_PROVIDE, OP_READ, OP_SUSPEND, OP_SUCCEED, OP_EMIT, OP_SUCCEED_NOW } from './opCodes/channel.esm.js';
 
 /** @internal */
 const ChannelSymbolKey = "effect/Channel";

package/internal/fiberRuntime.esm.js

@@ -8,6 +8,7 @@ import { getOrDefault } from '../FiberRefs/dist/effect-FiberRefs.esm.js';
 import { diff as diff$1, patch as patch$1 } from '../FiberRefsPatch/dist/effect-FiberRefsPatch.esm.js';
 import { isDone, done, suspended, running } from '../FiberStatus/dist/effect-FiberStatus.esm.js';
 import { dual, identity, pipe } from '../Function/dist/effect-Function.esm.js';
+import { map as map$1 } from '../HashMap/dist/effect-HashMap.esm.js';
 import { make, fromIterable as fromIterable$2, union, size } from '../HashSet/dist/effect-HashSet.esm.js';
 import { par, flatten as flatten$2, sequentialCollectionToChunk } from './blockedRequests.esm.js';
 import { pretty, failureOrCause, parallel as parallel$1, sequential as sequential$1, interrupt, isEmpty, isInterruptedOnly, die, NoSuchElementException, stripFailures, isInterruptedException, IllegalArgumentException } from './cause.esm.js';
@@ -15,7 +16,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, 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$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, fiberRefLocallyWith, 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';
@@ -24,7 +25,7 @@ import { _await, FiberTypeId, fiberVariance, join, RuntimeFiberTypeId, currentFi
 import { resume, stateful, interruptSignal, OP_STATEFUL, OP_RESUME, OP_INTERRUPT_SIGNAL, OP_YIELD_NOW, yieldNow } from './fiberMessage.esm.js';
 import { get, joinAs, delete_, updatedAs, forkAs, getOrDefault as getOrDefault$1 } from './fiberRefs.esm.js';
 import { globalScope, unsafeMake } from './fiberScope.esm.js';
-import { makeLogger, stringLogger, logfmtLogger } from './logger.esm.js';
+import { makeLogger, stringLogger, logfmtLogger, serializeUnknown } from './logger.esm.js';
 import { counter, tagged, histogram } from './metric.esm.js';
 import { exponential } from './metric/boundaries.esm.js';
 import { make as make$3 } from './metric/label.esm.js';
@@ -868,7 +869,7 @@ class FiberRuntime {
     }
   }
   [OP_TAG](op) {
-    return map$1(fiberRefGet(currentContext), context => {
+    return map$2(fiberRefGet(currentContext), context => {
       try {
         return unsafeGet(context, op);
       } catch (e) {
@@ -1179,7 +1180,7 @@ const tracerLogger = /*#__PURE__*/makeLogger(({
   if (span._tag === "None" || span.value._tag === "ExternalSpan" || clockService._tag === "None") {
     return;
   }
-  const attributes = Object.fromEntries(annotations);
+  const attributes = Object.fromEntries(map$1(annotations, value => serializeUnknown(value)));
   attributes["effect.fiberId"] = threadName(fiberId);
   attributes["effect.logLevel"] = logLevel.label;
   if (cause !== null && cause._tag !== "Empty") {
@@ -1247,8 +1248,8 @@ const existsLoop = (iterator, index, f) => {
 
 /* @internal */
 const filter = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => {
-  const predicate = options?.negate ? (a, i) => map$1(f(a, i), not) : f;
-  return matchSimple(options, () => suspend(() => fromIterable(elements).reduceRight((effect, a, i) => zipWith(effect, suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), sync(() => new Array()))), () => map$1(forEachOptions(elements, (a, i) => map$1(predicate(a, i), b => b ? some(a) : none()), options), compact));
+  const predicate = options?.negate ? (a, i) => map$2(f(a, i), not) : f;
+  return matchSimple(options, () => suspend(() => fromIterable(elements).reduceRight((effect, a, i) => zipWith(effect, suspend(() => predicate(a, i)), (list, b) => b ? [a, ...list] : list), sync(() => new Array()))), () => map$2(forEachOptions(elements, (a, i) => map$2(predicate(a, i), b => b ? some(a) : none()), options), compact));
 });
 
 // === all
@@ -1311,7 +1312,7 @@ const allEither = (effects, reconcile, options) => {
       discard: true
     });
   }
-  return map$1(forEachOptions(eitherEffects, identity, {
+  return map$2(forEachOptions(eitherEffects, identity, {
     concurrency: options?.concurrency,
     batching: options?.batching
   }), eithers => reconcile._tag === "Some" ? reconcile.value(eithers) : eithers);
@@ -1325,14 +1326,14 @@ const all = (arg, options) => {
   } else if (options?.mode === "either") {
     return allEither(effects, reconcile, options);
   }
-  return reconcile._tag === "Some" ? map$1(forEachOptions(effects, identity, options), reconcile.value) : forEachOptions(effects, identity, options);
+  return reconcile._tag === "Some" ? map$2(forEachOptions(effects, identity, options), reconcile.value) : forEachOptions(effects, identity, options);
 };
 
 /* @internal */
 const allWith = options => arg => all(arg, options);
 
 /* @internal */
-const allSuccesses = (elements, options) => map$1(all(fromIterable(elements).map(exit), options), filterMap(exit => exitIsSuccess(exit) ? some(exit.i0) : none()));
+const allSuccesses = (elements, options) => map$2(all(fromIterable(elements).map(exit), options), filterMap(exit => exitIsSuccess(exit) ? some(exit.i0) : none()));
 
 /* @internal */
 const replicate = /*#__PURE__*/dual(2, (self, n) => Array.from({
@@ -1440,7 +1441,7 @@ const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
             return unit;
           }
       }
-    }))), forkDaemon, map$1(fiber => {
+    }))), forkDaemon, map$2(fiber => {
       fiber.addObserver(() => {
         joinOrder.push(fiber);
       });
@@ -1466,7 +1467,7 @@ const forEachParUnboundedDiscard = (self, f, batching) => suspend(() => {
 const forEachParN = (self, n, f, batching) => suspend(() => {
   const as = fromIterable(self);
   const array = new Array(as.length);
-  const fn = (a, i) => map$1(f(a, i), b => array[i] = b);
+  const fn = (a, i) => map$2(f(a, i), b => array[i] = b);
   return zipRight(forEachParNDiscard(as, n, fn, batching), succeed(array));
 });
 
@@ -1560,7 +1561,7 @@ const forkWithScopeOverride = (self, scopeOverride) => withFiberRuntime((parentF
 const mergeAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, zero, f, options) => matchSimple(options, () => fromIterable(elements).reduce((acc, a, i) => zipWith(acc, a, (acc, a) => f(acc, a, i)), succeed(zero)), () => flatMap$1(make$1(zero), acc => flatMap$1(forEachOptions(elements, (effect, i) => flatMap$1(effect, a => update(acc, b => f(b, a, i))), options), () => get$2(acc)))));
 
 /* @internal */
-const partition = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => pipe(forEachOptions(elements, (a, i) => either(f(a, i)), options), map$1(chunk => partitionMap(chunk, identity))));
+const partition = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => pipe(forEachOptions(elements, (a, i) => either(f(a, i)), options), map$2(chunk => partitionMap(chunk, identity))));
 
 /* @internal */
 const validateAll = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, f, options) => flatMap$1(partition(elements, f, {
@@ -1577,7 +1578,7 @@ const raceAll = all => {
   const self = headNonEmpty(list);
   const effects = tailNonEmpty(list);
   const inheritAll$1 = res => pipe(inheritAll(res[1]), as(res[0]));
-  return pipe(deferredMake(), flatMap$1(done => pipe(make$1(effects.length), flatMap$1(fails => uninterruptibleMask(restore => pipe(fork(interruptible(self)), flatMap$1(head => pipe(effects, forEachSequential(effect => fork(interruptible(effect))), map$1(unsafeFromArray), map$1(tail => pipe(tail, prepend(head))), tap(fibers => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipRight(pipe(_await(fiber), flatMap$1(raceAllArbiter(fibers, fiber, done, fails)), fork, asUnit)))))), flatMap$1(fibers => pipe(restore(pipe(_await$1(done), flatMap$1(inheritAll$1))), onInterrupt(() => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipLeft(interruptFiber(fiber))))))))))))))));
+  return pipe(deferredMake(), flatMap$1(done => pipe(make$1(effects.length), flatMap$1(fails => uninterruptibleMask(restore => pipe(fork(interruptible(self)), flatMap$1(head => pipe(effects, forEachSequential(effect => fork(interruptible(effect))), map$2(unsafeFromArray), map$2(tail => pipe(tail, prepend(head))), tap(fibers => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipRight(pipe(_await(fiber), flatMap$1(raceAllArbiter(fibers, fiber, done, fails)), fork, asUnit)))))), flatMap$1(fibers => pipe(restore(pipe(_await$1(done), flatMap$1(inheritAll$1))), onInterrupt(() => pipe(fibers, reduce(unit, (effect, fiber) => pipe(effect, zipLeft(interruptFiber(fiber))))))))))))))));
 };
 
 /* @internal */
@@ -1598,7 +1599,7 @@ const reduceEffect = /*#__PURE__*/dual(args => isIterable(args[0]), (elements, z
         return some(f(acc.value, elem, i));
       }
   }
-}, options), map$1(option => {
+}, options), map$2(option => {
   switch (option._tag) {
     case "None":
       {
@@ -1703,7 +1704,7 @@ const withClockScoped = value => fiberRefLocallyScopedWith(currentServices, add(
 const withConfigProviderScoped = value => fiberRefLocallyScopedWith(currentServices, add(configProviderTag, value));
 
 /* @internal */
-const withEarlyRelease = self => scopeWith(parent => flatMap$1(scopeFork(parent, sequential$2), child => pipe(self, scopeExtend(child), map$1(value => [fiberIdWith(fiberId => scopeClose(child, exitInterrupt(fiberId))), value]))));
+const withEarlyRelease = self => scopeWith(parent => flatMap$1(scopeFork(parent, sequential$2), child => pipe(self, scopeExtend(child), map$2(value => [fiberIdWith(fiberId => scopeClose(child, exitInterrupt(fiberId))), value]))));
 
 /** @internal */
 const zipOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (a, b) => [a, b], options));
@@ -1715,7 +1716,7 @@ const zipLeftOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that,
 const zipRightOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, options) => zipWithOptions(self, that, (_, b) => b, options));
 
 /** @internal */
-const zipWithOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f, options) => map$1(all([self, that], {
+const zipWithOptions = /*#__PURE__*/dual(args => isEffect(args[1]), (self, that, f, options) => map$2(all([self, that], {
   concurrency: options?.concurrent ? 2 : 1,
   batching: options?.batching
 }), ([a, a2]) => f(a, a2)));
@@ -1770,7 +1771,7 @@ const scopeTag = /*#__PURE__*/Tag(ScopeTypeId);
 const scope = scopeTag;
 
 /* @internal */
-const scopeMake = (strategy = sequential$2) => map$1(releaseMapMake, rm => ({
+const scopeMake = (strategy = sequential$2) => map$2(releaseMapMake, rm => ({
   [ScopeTypeId]: ScopeTypeId,
   [CloseableScopeTypeId]: CloseableScopeTypeId,
   strategy,
@@ -1834,9 +1835,9 @@ const fiberAll = fibers => ({
   [FiberTypeId]: fiberVariance,
   id: () => fromIterable(fibers).reduce((id, fiber) => combine(id, fiber.id()), none$2),
   await: () => exit(forEachParUnbounded(fibers, fiber => flatten(fiber.await()), false)),
-  children: () => map$1(forEachParUnbounded(fibers, fiber => fiber.children(), false), flatten$1),
+  children: () => map$2(forEachParUnbounded(fibers, fiber => fiber.children(), false), flatten$1),
   inheritAll: () => forEachSequentialDiscard(fibers, fiber => fiber.inheritAll()),
-  poll: () => map$1(forEachSequential(fibers, fiber => fiber.poll()), reduceRight(some(exitSucceed(new Array())), (optionB, optionA) => {
+  poll: () => map$2(forEachSequential(fibers, fiber => fiber.poll()), reduceRight(some(exitSucceed(new Array())), (optionB, optionA) => {
     switch (optionA._tag) {
       case "None":
         {
@@ -1994,15 +1995,18 @@ const interruptWhenPossible = /*#__PURE__*/dual(2, (self, all) => fiberRefGetWit
 // circular Tracer
 
 /** @internal */
-const useSpanScoped = (name, options) => acquireRelease(makeSpan(name, options), (span, exit) => flatMap$1(currentTimeNanosTracing, endTime => sync(() => span.end(endTime, exit))));
+const makeSpanScoped = (name, options) => acquireRelease(makeSpan(name, options), (span, exit) => flatMap$1(currentTimeNanosTracing, endTime => sync(() => span.end(endTime, exit))));
 
 /* @internal */
-const withSpanScoped = (name, options) => flatMap$1(useSpanScoped(name, options), span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span)));
+const setSpan = (name, options) => tap(makeSpanScoped(name, options), span => setParentSpan(span));
 
 /* @internal */
 const withTracerScoped = value => fiberRefLocallyScopedWith(currentServices, add(tracerTag, value));
 
 /* @internal */
-const withParentSpanScoped = span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span));
+const setParentSpan = span => fiberRefLocallyScopedWith(currentTracerSpan, prepend$1(span));
 
-export { FiberRuntime, acquireRelease, acquireReleaseInterruptible, addFinalizer, all, allSuccesses, allWith, currentLoggers, currentMinimumLogLevel, currentRuntimeFlags, currentSupervisor, daemonChildren, defaultLogger, disconnect, ensuring, exists, fiberActive, fiberAll, fiberAwaitAll, fiberFailures, fiberInterruptFork, fiberJoinAll, fiberLifetimes, fiberRefLocallyScoped, fiberRefLocallyScopedWith, fiberRefMake, fiberRefMakeContext, fiberRefMakeRuntimeFlags, fiberRefMakeWith, fiberRefUnsafeMakeSupervisor, fiberScoped, fiberStarted, fiberSuccesses, filter, finalizersMask, forEachOptions, forEachParN, forEachParNDiscard, forEachParUnbounded, forEachParUnboundedDiscard, fork, forkDaemon, forkWithErrorHandler, getConsole, interruptWhenPossible, invokeWithInterrupt, labelMetricsScoped, labelMetricsScopedSet, logFmtLogger, mergeAll, parallelFinalizers, parallelNFinalizers, partition, race, raceAll, raceFibersWith, raceWith, reduceEffect, releaseMapReleaseAll, replicate, replicateEffect, runtimeFiberVariance, scope, scopeExtend, scopeMake, scopeTag, scopeUse, scopeWith, scopedEffect, sequentialFinalizers, tagMetricsScoped, tracerLogger, unsafeFork, unsafeMakeChildFiber, useSpanScoped, using, validate, validateAll, validateFirst, validateWith, withClockScoped, withConfigProviderScoped, withEarlyRelease, withParentSpanScoped, withRuntimeFlagsScoped, withSpanScoped, withTracerScoped, zipLeftOptions, zipOptions, zipRightOptions, zipWithOptions };
+/** @internal */
+const withSpanScoped = /*#__PURE__*/dual(args => typeof args[0] !== "string", (self, name, options) => flatMap$1(makeSpanScoped(name, options), span => fiberRefLocallyWith(self, currentTracerSpan, prepend$1(span))));
+
+export { FiberRuntime, acquireRelease, acquireReleaseInterruptible, addFinalizer, all, allSuccesses, allWith, currentLoggers, currentMinimumLogLevel, currentRuntimeFlags, currentSupervisor, daemonChildren, defaultLogger, disconnect, ensuring, exists, fiberActive, fiberAll, fiberAwaitAll, fiberFailures, fiberInterruptFork, fiberJoinAll, fiberLifetimes, fiberRefLocallyScoped, fiberRefLocallyScopedWith, fiberRefMake, fiberRefMakeContext, fiberRefMakeRuntimeFlags, fiberRefMakeWith, fiberRefUnsafeMakeSupervisor, fiberScoped, fiberStarted, fiberSuccesses, filter, finalizersMask, forEachOptions, forEachParN, forEachParNDiscard, forEachParUnbounded, forEachParUnboundedDiscard, fork, forkDaemon, forkWithErrorHandler, getConsole, interruptWhenPossible, invokeWithInterrupt, labelMetricsScoped, labelMetricsScopedSet, logFmtLogger, makeSpanScoped, mergeAll, parallelFinalizers, parallelNFinalizers, partition, race, raceAll, raceFibersWith, raceWith, reduceEffect, releaseMapReleaseAll, replicate, replicateEffect, runtimeFiberVariance, scope, scopeExtend, scopeMake, scopeTag, scopeUse, scopeWith, scopedEffect, sequentialFinalizers, setParentSpan, setSpan, tagMetricsScoped, tracerLogger, unsafeFork, unsafeMakeChildFiber, using, validate, validateAll, validateFirst, validateWith, withClockScoped, withConfigProviderScoped, withEarlyRelease, withRuntimeFlagsScoped, withSpanScoped, withTracerScoped, zipLeftOptions, zipOptions, zipRightOptions, zipWithOptions };

package/internal/groupBy.esm.js

@@ -11,7 +11,7 @@ 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 { flatMap, flattenTake, fromQueue, filterEffect, map, zipWithIndex, unwrapScoped, mapEffectSequential, distributedWithDynamicCallback, flattenExitOption, isStream, matchConcurrency, fromEffect, mapEffectPar, toChannel } from './stream.esm.js';
 import { TakeImpl, of as of$1, chunk, failCause, end } from './take.esm.js';
 
 /** @internal */
@@ -29,7 +29,10 @@ const groupByVariance = {
 };
 
 /** @internal */
-const evaluate = /*#__PURE__*/dual(3, (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue(queue, {
+const isGroupBy = u => typeof u === "object" && u != null && GroupByTypeId in u;
+
+/** @internal */
+const evaluate = /*#__PURE__*/dual(args => isGroupBy(args[0]), (self, f, options) => flatMap(self.grouped, ([key, queue]) => f(key, flattenTake(fromQueue(queue, {
   shutdown: true
 }))), {
   concurrency: "unbounded",
@@ -66,7 +69,7 @@ const make = grouped => ({
 // Circular with Stream
 
 /** @internal */
-const groupBy = /*#__PURE__*/dual(args => typeof args[0] !== "function", (self, f, options) => make(unwrapScoped(gen(function* ($) {
+const groupBy = /*#__PURE__*/dual(args => isStream(args[0]), (self, f, options) => make(unwrapScoped(gen(function* ($) {
   const decider = yield* $(make$1());
   const output = yield* $(acquireRelease(bounded(options?.bufferSize ?? 16), queue => shutdown(queue)));
   const ref = yield* $(make$2(new Map()));
@@ -85,7 +88,7 @@ const mapEffectOptions = /*#__PURE__*/dual(args => typeof args[0] !== "function"
   if (options?.key) {
     return evaluate(groupByKey(self, options.key, {
       bufferSize: options.bufferSize
-    }), (_, s) => pipe(s, mapEffectSequential(f)));
+    }), (_, s) => mapEffectSequential(s, f));
   }
   return matchConcurrency(options?.concurrency, () => mapEffectSequential(self, f), n => options?.unordered ? flatMap(self, a => fromEffect(f(a)), {
     concurrency: n
@@ -205,4 +208,4 @@ const groupByIterable = /*#__PURE__*/dual(2, (iterable, f) => {
   return unsafeFromArray(builder.map(tuple => [tuple[0], unsafeFromArray(tuple[1])]));
 });
 
-export { GroupByTypeId, bindEffect, evaluate, filter, first, groupBy, groupByIterable, groupByKey, make, mapEffectOptions };
+export { GroupByTypeId, bindEffect, evaluate, filter, first, groupBy, groupByIterable, groupByKey, isGroupBy, make, mapEffectOptions };

package/internal/layer/circular.esm.js

@@ -1,12 +1,11 @@
 import { dual } from '../../Function/dist/effect-Function.esm.js';
 import { add, remove } from '../../HashSet/dist/effect-HashSet.esm.js';
-import { fiberRefLocally, map } from '../core.esm.js';
-import { fiberRefLocallyScoped, currentMinimumLogLevel, fiberRefLocallyScopedWith, currentLoggers, currentSupervisor, withRuntimeFlagsScoped, withConfigProviderScoped, withParentSpanScoped, withSpanScoped, withTracerScoped } from '../fiberRuntime.esm.js';
-import { scopedDiscard, flatMap } from '../layer.esm.js';
+import { fiberRefLocally, map, tap, zipRight } from '../core.esm.js';
+import { fiberRefLocallyScoped, currentMinimumLogLevel, fiberRefLocallyScopedWith, currentLoggers, currentSupervisor, withRuntimeFlagsScoped, withConfigProviderScoped, setParentSpan as setParentSpan$1, makeSpanScoped, addFinalizer, setSpan as setSpan$1, withTracerScoped } from '../fiberRuntime.esm.js';
+import { scopedDiscard, unwrapEffect, unwrapScoped, flatMap } from '../layer.esm.js';
 import { CooperativeYielding, Interruption, OpSupervision, RuntimeMetrics, WindDown } from '../runtimeFlags.esm.js';
 import { enable, disable } from '../runtimeFlagsPatch.esm.js';
 import { Zip } from '../supervisor.esm.js';
-import { unwrapEffect, unwrapScoped } from '../../Layer/dist/effect-Layer.esm.js';
 
 // circular with Logger
 /** @internal */
@@ -73,10 +72,10 @@ const disableWindDown = /*#__PURE__*/scopedDiscard( /*#__PURE__*/withRuntimeFlag
 const setConfigProvider = configProvider => scopedDiscard(withConfigProviderScoped(configProvider));
 
 /** @internal */
-const setParentSpan = span => scopedDiscard(withParentSpanScoped(span));
+const setParentSpan = span => scopedDiscard(setParentSpan$1(span));
 
 /** @internal */
-const setSpan = (name, options) => scopedDiscard(withSpanScoped(name, options));
+const setSpan = (name, options) => scopedDiscard(options?.onEnd ? tap(makeSpanScoped(name, options), span => zipRight(addFinalizer(exit => options.onEnd(span, exit)), setParentSpan$1(span))) : setSpan$1(name, options));
 
 /** @internal */
 const setTracer = tracer => scopedDiscard(withTracerScoped(tracer));

package/internal/layer.esm.js

@@ -4,15 +4,16 @@ import { empty, get, make, merge as merge$1, unsafeGet, Tag, isContext, isTag }
 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';
-import { flatMap as flatMap$1, sync as sync$1, zipWith, provideContext, matchCauseEffect, context as context$1, failCause as failCause$1, failCauseSync as failCauseSync$1, map as map$1, fiberRefLocally as fiberRefLocally$1, fiberRefLocallyWith as fiberRefLocallyWith$1, zipRight, never, as, succeed as succeed$1, fail as fail$2, provideSomeContext, acquireUseRelease, scopeClose, updateRuntimeFlags, flatten as flatten$1, onExit, exitMatch, unit, scopeAddFinalizerExit, deferredMake, uninterruptibleMask, exit, whenEffect, asUnit, deferredSucceed, deferredFailCause, deferredAwait, exitMatchEffect } from './core.esm.js';
-import { memoize as memoize$1, withParentSpan, patchFiberRefs, diffFiberRefs } from './core-effect.esm.js';
+import { flatMap as flatMap$1, sync as sync$1, zipWith, provideContext, matchCauseEffect, context as context$1, failCause as failCause$1, failCauseSync as failCauseSync$1, map as map$1, fiberRefLocally as fiberRefLocally$1, fiberRefLocallyWith as fiberRefLocallyWith$1, zipRight, never, as, succeed as succeed$1, fail as fail$2, tap as tap$1, currentTracerSpan, provideSomeContext, acquireUseRelease, scopeClose, updateRuntimeFlags, flatten as flatten$1, onExit, exitMatch, unit, scopeAddFinalizerExit, deferredMake, uninterruptibleMask, exit, whenEffect, asUnit, deferredSucceed, deferredFailCause, deferredAwait, exitMatchEffect } from './core.esm.js';
+import { memoize as memoize$1, patchFiberRefs, diffFiberRefs } from './core-effect.esm.js';
 import { makeSynchronized } from './effect/circular.esm.js';
-import { scopeWith, zipWithOptions, scopeExtend, fiberRefLocallyScoped as fiberRefLocallyScoped$1, fiberRefLocallyScopedWith as fiberRefLocallyScopedWith$1, scopedEffect, acquireRelease, scopeMake, useSpanScoped } from './fiberRuntime.esm.js';
+import { scopeWith, zipWithOptions, scopeExtend, fiberRefLocallyScoped as fiberRefLocallyScoped$1, fiberRefLocallyScopedWith as fiberRefLocallyScopedWith$1, scopedEffect, acquireRelease, scopeMake, makeSpanScoped, addFinalizer } from './fiberRuntime.esm.js';
 import { OP_SUCCESS, OP_FAILURE } from './opCodes/effect.esm.js';
 import { OP_FRESH, OP_EXTEND_SCOPE, OP_FROM_EFFECT, OP_FOLD, OP_ZIP_WITH, OP_SCOPED, OP_SUSPEND, OP_PROVIDE_TO, OP_ZIP_WITH_PAR } from './opCodes/layer.esm.js';
 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 { prepend } from '../List/dist/effect-List.esm.js';
 import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
 import { isDone } from '../ScheduleDecision/dist/effect-ScheduleDecision.esm.js';
 import { start } from '../ScheduleIntervals/dist/effect-ScheduleIntervals.esm.js';
@@ -552,7 +553,10 @@ const unwrapScoped = self => {
 // -----------------------------------------------------------------------------
 
 /** @internal */
-const withSpan = /*#__PURE__*/dual(args => isLayer(args[0]), (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(options?.onEnd ? tap$1(makeSpanScoped(name, options), span => addFinalizer(exit => options.onEnd(span, exit))) : makeSpanScoped(name, options), span => withParentSpan(self, span))));
+
+/** @internal */
+const withParentSpan = /*#__PURE__*/dual(2, (self, span) => fiberRefLocallyWith(self, currentTracerSpan, prepend(span)));
 
 // circular with Effect
 
@@ -568,4 +572,4 @@ const provideSomeRuntime = /*#__PURE__*/dual(2, (self, rt) => {
 /** @internal */
 const effect_provide = /*#__PURE__*/dual(2, (self, source) => isLayer(source) ? provideSomeLayer(self, source) : isContext(source) ? provideSomeContext(self, source) : provideSomeRuntime(self, source));
 
-export { LayerTypeId, build, buildWithScope, catchAll, catchAllCause, context, die, dieSync, discard, effect_provide, extendScope, fail, failCause, failCauseSync, failSync, fiberRefLocally, fiberRefLocallyScoped, fiberRefLocallyScopedWith, fiberRefLocallyWith, flatMap, flatten, fresh, fromEffect, fromEffectContext, fromEffectDiscard, fromFunction, isFresh, isLayer, launch, locallyEffect, map, mapError, match, matchCause, memoize, merge, mergeAll, orDie, orElse, passthrough, project, provide, provideMerge, retry, scope, scoped, scopedContext, scopedDiscard, service, succeed, succeedContext, suspend, sync, syncContext, tap, tapError, tapErrorCause, toRuntime, unwrapEffect, unwrapScoped, use, useMerge, withSpan, zipWithPar };
+export { LayerTypeId, build, buildWithScope, catchAll, catchAllCause, context, die, dieSync, discard, effect_provide, extendScope, fail, failCause, failCauseSync, failSync, fiberRefLocally, fiberRefLocallyScoped, fiberRefLocallyScopedWith, fiberRefLocallyWith, flatMap, flatten, fresh, fromEffect, fromEffectContext, fromEffectDiscard, fromFunction, isFresh, isLayer, launch, locallyEffect, map, mapError, match, matchCause, memoize, merge, mergeAll, orDie, orElse, passthrough, project, provide, provideMerge, retry, scope, scoped, scopedContext, scopedDiscard, service, succeed, succeedContext, suspend, sync, syncContext, tap, tapError, tapErrorCause, toRuntime, unwrapEffect, unwrapScoped, use, useMerge, withParentSpan, withSpan, zipWithPar };

package/internal/logger.esm.js

@@ -124,7 +124,7 @@ const stringLogger = /*#__PURE__*/makeLogger(({
       }
       output = output + filterKeyName(key);
       output = output + "=";
-      output = appendQuoted(String(value), output);
+      output = appendQuoted(serializeUnknown(value), output);
     }
   }
   return output;
@@ -189,7 +189,7 @@ const logfmtLogger = /*#__PURE__*/makeLogger(({
       }
       output = output + filterKeyName(key);
       output = output + "=";
-      output = appendQuotedLogfmt(String(value), output);
+      output = appendQuotedLogfmt(serializeUnknown(value), output);
     }
   }
   return output;
@@ -210,4 +210,4 @@ const renderLogSpanLogfmt = now => self => {
   return `${label}=${now - self.startTime}ms`;
 };
 
-export { LoggerTypeId, filterLogLevel, logfmtLogger, makeLogger, map, mapInput, none, simple, stringLogger, succeed, sync, zip, zipLeft, zipRight };
+export { LoggerTypeId, filterLogLevel, logfmtLogger, makeLogger, map, mapInput, none, serializeUnknown, simple, stringLogger, succeed, sync, zip, zipLeft, zipRight };