effect 2.0.0-next.46 → 2.0.0-next.48

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/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 };

package/internal/matcher.esm.js

@@ -0,0 +1,314 @@
+import { left, isEither, right, match } from '../Either/dist/effect-Either.esm.js';
+import { identity } from '../Function/dist/effect-Function.esm.js';
+import { none, some } from '../Option/dist/effect-Option.esm.js';
+import { pipeArguments } from '../Pipeable/dist/effect-Pipeable.esm.js';
+
+/** @internal */
+const TypeId = /*#__PURE__*/Symbol.for("@effect/matcher/Matcher");
+const TypeMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _remaining: identity,
+    _result: identity
+  },
+  _tag: "TypeMatcher",
+  add(_case) {
+    return makeTypeMatcher([...this.cases, _case]);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeTypeMatcher(cases) {
+  const matcher = Object.create(TypeMatcherProto);
+  matcher.cases = cases;
+  return matcher;
+}
+const ValueMatcherProto = {
+  [TypeId]: {
+    _input: identity,
+    _filters: identity,
+    _result: identity
+  },
+  _tag: "ValueMatcher",
+  add(_case) {
+    if (this.value._tag === "Right") {
+      return this;
+    }
+    if (_case._tag === "When" && _case.guard(this.provided) === true) {
+      return makeValueMatcher(this.provided, right(_case.evaluate(this.provided)));
+    } else if (_case._tag === "Not" && _case.guard(this.provided) === false) {
+      return makeValueMatcher(this.provided, right(_case.evaluate(this.provided)));
+    }
+    return this;
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeValueMatcher(provided, value) {
+  const matcher = Object.create(ValueMatcherProto);
+  matcher.provided = provided;
+  matcher.value = value;
+  return matcher;
+}
+const makeWhen = (guard, evaluate) => ({
+  _tag: "When",
+  guard,
+  evaluate
+});
+const makeNot = (guard, evaluate) => ({
+  _tag: "Not",
+  guard,
+  evaluate
+});
+const makePredicate = pattern => {
+  if (typeof pattern === "function") {
+    return pattern;
+  } else if (Array.isArray(pattern)) {
+    const predicates = pattern.map(makePredicate);
+    const len = predicates.length;
+    return u => {
+      if (!Array.isArray(u)) {
+        return false;
+      }
+      for (let i = 0; i < len; i++) {
+        if (predicates[i](u[i]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  } else if (pattern !== null && typeof pattern === "object") {
+    const keysAndPredicates = Object.entries(pattern).map(([k, p]) => [k, makePredicate(p)]);
+    const len = keysAndPredicates.length;
+    return u => {
+      if (typeof u !== "object" || u === null) {
+        return false;
+      }
+      for (let i = 0; i < len; i++) {
+        const [key, predicate] = keysAndPredicates[i];
+        if (!(key in u) || predicate(u[key]) === false) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+  return u => u === pattern;
+};
+const makeOrPredicate = patterns => {
+  const predicates = patterns.map(makePredicate);
+  const len = predicates.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (predicates[i](u) === true) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+const makeAndPredicate = patterns => {
+  const predicates = patterns.map(makePredicate);
+  const len = predicates.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (predicates[i](u) === false) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+
+/** @internal */
+const type = () => makeTypeMatcher([]);
+
+/** @internal */
+const value = i => makeValueMatcher(i, left(i));
+
+/** @internal */
+const valueTags = fields => {
+  const match = tagsExhaustive(fields)(makeTypeMatcher([]));
+  return input => match(input);
+};
+
+/** @internal */
+const typeTags = () => fields => {
+  const match = tagsExhaustive(fields)(makeTypeMatcher([]));
+  return input => match(input);
+};
+
+/** @internal */
+const when = (pattern, f) => self => self.add(makeWhen(makePredicate(pattern), f));
+
+/** @internal */
+const whenOr = (...args) => self => {
+  const onMatch = args[args.length - 1];
+  const patterns = args.slice(0, -1);
+  return self.add(makeWhen(makeOrPredicate(patterns), onMatch));
+};
+
+/** @internal */
+const whenAnd = (...args) => self => {
+  const onMatch = args[args.length - 1];
+  const patterns = args.slice(0, -1);
+  return self.add(makeWhen(makeAndPredicate(patterns), onMatch));
+};
+
+/** @internal */
+const discriminator = field => (...pattern) => {
+  const f = pattern[pattern.length - 1];
+  const values = pattern.slice(0, -1);
+  const pred = values.length === 1 ? _ => _[field] === values[0] : _ => values.includes(_[field]);
+  return self => self.add(makeWhen(pred, f));
+};
+
+/** @internal */
+const discriminatorStartsWith = field => (pattern, f) => {
+  const pred = _ => typeof _[field] === "string" && _[field].startsWith(pattern);
+  return self => self.add(makeWhen(pred, f));
+};
+
+/** @internal */
+const discriminators = field => fields => {
+  const predicates = [];
+  for (const key in fields) {
+    const pred = _ => _[field] === key;
+    const f = fields[key];
+    if (f) {
+      predicates.push(makeWhen(pred, f));
+    }
+  }
+  const len = predicates.length;
+  return self => {
+    let matcher = self;
+    for (let i = 0; i < len; i++) {
+      matcher = matcher.add(predicates[i]);
+    }
+    return matcher;
+  };
+};
+
+/** @internal */
+const discriminatorsExhaustive = field => fields => {
+  const addCases = discriminators(field)(fields);
+  return matcher => exhaustive(addCases(matcher));
+};
+
+/** @internal */
+const tag = /*#__PURE__*/discriminator("_tag");
+
+/** @internal */
+const tagStartsWith = /*#__PURE__*/discriminatorStartsWith("_tag");
+
+/** @internal */
+const tags = /*#__PURE__*/discriminators("_tag");
+
+/** @internal */
+const tagsExhaustive = /*#__PURE__*/discriminatorsExhaustive("_tag");
+
+/** @internal */
+const not = (pattern, f) => self => self.add(makeNot(makePredicate(pattern), f));
+
+/** @internal */
+const nonEmptyString = u => typeof u === "string" && u.length > 0;
+
+/** @internal */
+const is = (...literals) => {
+  const len = literals.length;
+  return u => {
+    for (let i = 0; i < len; i++) {
+      if (u === literals[i]) {
+        return true;
+      }
+    }
+    return false;
+  };
+};
+
+/** @internal */
+const any = () => true;
+
+/** @internal */
+const defined = u => u !== undefined && u !== null;
+
+/** @internal */
+const instanceOf = constructor => u => u instanceof constructor;
+
+/** @internal */
+const orElse = f => self => {
+  const result = either(self);
+  if (isEither(result)) {
+    // @ts-expect-error
+    return result._tag === "Right" ? result.right : f(result.left);
+  }
+
+  // @ts-expect-error
+  return input => {
+    const a = result(input);
+    return a._tag === "Right" ? a.right : f(a.left);
+  };
+};
+
+/** @internal */
+const orElseAbsurd = self => orElse(() => {
+  throw new Error("absurd");
+})(self);
+
+/** @internal */
+const either = self => {
+  if (self._tag === "ValueMatcher") {
+    return self.value;
+  }
+  const len = self.cases.length;
+  return input => {
+    for (let i = 0; i < len; i++) {
+      const _case = self.cases[i];
+      if (_case._tag === "When" && _case.guard(input) === true) {
+        return right(_case.evaluate(input));
+      } else if (_case._tag === "Not" && _case.guard(input) === false) {
+        return right(_case.evaluate(input));
+      }
+    }
+    return left(input);
+  };
+};
+
+/** @internal */
+const option = self => {
+  const toEither = either(self);
+  if (isEither(toEither)) {
+    return match(toEither, {
+      onLeft: () => none(),
+      onRight: some
+    });
+  }
+  return input => match(toEither(input), {
+    onLeft: () => none(),
+    onRight: some
+  });
+};
+
+/** @internal */
+const exhaustive = self => {
+  const toEither = either(self);
+  if (isEither(toEither)) {
+    if (toEither._tag === "Right") {
+      return toEither.right;
+    }
+    throw new Error("@effect/match: exhaustive absurd");
+  }
+  return u => {
+    // @ts-expect-error
+    const result = toEither(u);
+    if (result._tag === "Right") {
+      return result.right;
+    }
+    throw new Error("@effect/match: exhaustive absurd");
+  };
+};
+
+export { TypeId, any, defined, discriminator, discriminatorStartsWith, discriminators, discriminatorsExhaustive, either, exhaustive, instanceOf, is, nonEmptyString, not, option, orElse, orElseAbsurd, tag, tagStartsWith, tags, tagsExhaustive, type, typeTags, value, valueTags, when, whenAnd, whenOr };