effect 2.0.0-next.47 → 2.0.0-next.48

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

package/internal/stream.esm.js

@@ -1,11 +1,11 @@
 import { flipCauseOption, failureOrCause, map as map$3, isInterrupted, die as die$2, IllegalArgumentException, RuntimeException, isDieType, isRuntimeException, squash } from '../Cause/dist/effect-Cause.esm.js';
 import { Done, Await } from '../ChannelMergeDecision/dist/effect-ChannelMergeDecision.esm.js';
-import { empty as empty$1, isNonEmpty, of, map as map$2, range as range$1, unsafeFromArray, reduceRight, prepend as prepend$1, isEmpty, dropWhile as dropWhile$1, filter as filter$1, filterMap as filterMap$1, filterMapWhile as filterMapWhile$1, findFirst, fromIterable as fromIterable$1, flatMap as flatMap$3, takeWhile as takeWhile$1, take as take$3, drop as drop$1, appendAll, unsafeLast, zipWith as zipWith$2, reduce, append, last as last$1, splitWhere, head as head$1, mapAccum as mapAccum$1, make as make$7, unsafeGet as unsafeGet$1, flatten as flatten$2, isChunk, splitAt, takeRight as takeRight$1 } from '../Chunk/dist/effect-Chunk.esm.js';
+import { empty as empty$1, isNonEmpty, of, map as map$2, range as range$1, unsafeFromArray, reduceRight, prepend as prepend$1, isEmpty, dropWhile as dropWhile$1, filter as filter$1, filterMap as filterMap$1, filterMapWhile as filterMapWhile$1, findFirst, fromIterable as fromIterable$1, flatMap as flatMap$3, takeWhile as takeWhile$1, take as take$3, drop as drop$1, appendAll, unsafeLast, zipWith as zipWith$2, reduce, append, last as last$1, splitWhere, head as head$1, mapAccum as mapAccum$1, make as make$7, unsafeGet as unsafeGet$1, flatten as flatten$2, isChunk, appendAllNonEmpty, splitAt, takeRight as takeRight$1 } from '../Chunk/dist/effect-Chunk.esm.js';
 import { sleep, currentTimeMillis } from '../Clock/dist/effect-Clock.esm.js';
 import { add, unsafeGet } from '../Context/dist/effect-Context.esm.js';
 import { make as make$4, succeed as succeed$2, await as _await, failCause as failCause$3, poll, fail as fail$4 } from '../Deferred/dist/effect-Deferred.esm.js';
 import { toMillis, millis, greaterThan, zero } from '../Duration/dist/effect-Duration.esm.js';
-import { acquireRelease as acquireRelease$1, all, when as when$1, flatMap as flatMap$2, zipRight as zipRight$1, succeed as succeed$1, map as map$1, forkScoped, scope, runtime, match as match$1, sync as sync$1, as as as$1, unit as unit$2, onError as onError$1, tap as tap$1, gen, suspend as suspend$1, transplant, die as die$1, dieSync as dieSync$1, dieMessage as dieMessage$1, makeSemaphore, matchCauseEffect, flatten as flatten$1, forEach, catchAllCause as catchAllCause$2, dropUntil as dropUntil$1, dropWhile as dropWhile$2, context as context$1, fail as fail$3, failSync as failSync$1, failCause as failCause$4, failCauseSync as failCauseSync$1, findFirst as findFirst$1, tryPromise, promise, isEffect, mapError as mapError$1, zip as zip$1, never as never$1, orDie as orDie$1, matchEffect, scoped as scoped$1, asUnit, forkDaemon, ensuring as ensuring$2, timeoutFail as timeoutFail$1, timeoutFailCause as timeoutFailCause$1, runSync, catchTags as catchTags$1, tapErrorCause as tapErrorCause$1, runPromise, withSpanScoped, raceWith, zipWith as zipWith$1, forkIn, reduce as reduce$1, catchSomeCause as catchSomeCause$1, orElse as orElse$2, zipLeft as zipLeft$1, catchAll as catchAll$2, asSome, succeedNone, fork } from '../Effect/dist/effect-Effect.esm.js';
+import { acquireRelease as acquireRelease$1, all, when as when$1, flatMap as flatMap$2, zipRight as zipRight$1, succeed as succeed$1, map as map$1, forkScoped, scope, runtime, match as match$1, sync as sync$1, as as as$1, unit as unit$2, onError as onError$1, tap as tap$1, gen, suspend as suspend$1, transplant, die as die$1, dieSync as dieSync$1, dieMessage as dieMessage$1, makeSemaphore, matchCauseEffect, flatten as flatten$1, forEach, catchAllCause as catchAllCause$2, dropUntil as dropUntil$1, dropWhile as dropWhile$2, context as context$1, fail as fail$3, failSync as failSync$1, failCause as failCause$4, failCauseSync as failCauseSync$1, findFirst as findFirst$1, tryPromise, promise, isEffect, mapError as mapError$1, zip as zip$1, never as never$1, orDie as orDie$1, matchEffect, scoped as scoped$1, asUnit, forkDaemon, ensuring as ensuring$2, timeoutFail as timeoutFail$1, timeoutFailCause as timeoutFailCause$1, runSync, catchTags as catchTags$1, tapErrorCause as tapErrorCause$1, runPromise, setSpan, raceWith, zipWith as zipWith$1, forkIn, reduce as reduce$1, catchSomeCause as catchSomeCause$1, orElse as orElse$2, zipLeft as zipLeft$1, catchAll as catchAll$2, asSome, succeedNone, fork } 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 { match as match$3, failCause as failCause$2, fail as fail$2, isSuccess, succeed as succeed$4, unit as unit$3, isFailure } from '../Exit/dist/effect-Exit.esm.js';
@@ -1117,7 +1117,10 @@ const groupAdjacentBy = /*#__PURE__*/dual(2, (self, f) => {
             const input = unsafeGet$1(chunk, until);
             const updatedKey = f(input);
             if (!equals(key, updatedKey)) {
-              builder.push([key, unsafeFromArray(Array.from(tuple[1]).slice(from, until))]);
+              const previousChunk = tuple[1];
+              const additionalChunk = unsafeFromArray(Array.from(chunk).slice(from, until));
+              const group = appendAllNonEmpty(previousChunk, additionalChunk);
+              builder.push([key, group]);
               key = updatedKey;
               from = until;
               loop = false;
@@ -2470,7 +2473,7 @@ const whenCaseEffect = /*#__PURE__*/dual(2, (self, pf) => pipe(fromEffect(self),
 const whenEffect = /*#__PURE__*/dual(2, (self, effect) => pipe(fromEffect(effect), flatMap(bool => bool ? self : empty)));
 
 /** @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 zip = /*#__PURE__*/dual(2, (self, that) => pipe(self, zipWith(that, (a, a2) => [a, a2])));

package/internal/tracer.esm.js

@@ -1,4 +1,4 @@
-import { Tag } from '../Context/dist/effect-Context.esm.js';
+import { Tag, empty } from '../Context/dist/effect-Context.esm.js';
 import { globalValue } from '../GlobalValue/dist/effect-GlobalValue.esm.js';
 import { incrementAndGet, make as make$1 } from '../MutableRef/dist/effect-MutableRef.esm.js';
 
@@ -23,11 +23,12 @@ class NativeSpan {
   _tag = "Span";
   traceId = "native";
   events = [];
-  constructor(name, parent, context, links, startTime) {
+  constructor(name, parent, context, links, sampled, startTime) {
     this.name = name;
     this.parent = parent;
     this.context = context;
     this.links = links;
+    this.sampled = sampled;
     this.startTime = startTime;
     this.status = {
       _tag: "Started",
@@ -54,8 +55,17 @@ class NativeSpan {
 
 /** @internal */
 const nativeTracer = /*#__PURE__*/make({
-  span: (name, parent, context, links, startTime) => new NativeSpan(name, parent, context, links, startTime),
+  span: (name, parent, context, links, sampled, startTime) => new NativeSpan(name, parent, context, links, sampled, startTime),
   context: f => f()
 });
 
-export { NativeSpan, TracerTypeId, make, nativeTracer, tracerTag };
+/** @internal */
+const externalSpan = options => ({
+  _tag: "ExternalSpan",
+  spanId: options.spanId,
+  traceId: options.traceId,
+  sampled: options.sampled ?? true,
+  context: options.context ?? empty()
+});
+
+export { NativeSpan, TracerTypeId, externalSpan, make, nativeTracer, tracerTag };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effect",
-  "version": "2.0.0-next.47",
+  "version": "2.0.0-next.48",
   "packageManager": "pnpm@8.7.3",
   "publishConfig": {
     "access": "public"
@@ -34,7 +34,7 @@
     "src",
     "dist",
     "internal",
-    "Bigint",
+    "BigInt",
     "Boolean",
     "Brand",
     "Cache",
@@ -89,6 +89,7 @@
     "LogLevel",
     "LogSpan",
     "Logger",
+    "Match",
     "Metric",
     "MetricBoundaries",
     "MetricHook",
@@ -186,11 +187,11 @@
       "default": "./dist/effect.cjs.js"
     },
     "./package.json": "./package.json",
-    "./Bigint": {
-      "types": "./dist/declarations/src/Bigint.d.ts",
-      "module": "./Bigint/dist/effect-Bigint.esm.js",
-      "import": "./Bigint/dist/effect-Bigint.cjs.mjs",
-      "default": "./Bigint/dist/effect-Bigint.cjs.js"
+    "./BigInt": {
+      "types": "./dist/declarations/src/BigInt.d.ts",
+      "module": "./BigInt/dist/effect-BigInt.esm.js",
+      "import": "./BigInt/dist/effect-BigInt.cjs.mjs",
+      "default": "./BigInt/dist/effect-BigInt.cjs.js"
     },
     "./Boolean": {
       "types": "./dist/declarations/src/Boolean.d.ts",
@@ -516,6 +517,12 @@
       "import": "./Logger/dist/effect-Logger.cjs.mjs",
       "default": "./Logger/dist/effect-Logger.cjs.js"
     },
+    "./Match": {
+      "types": "./dist/declarations/src/Match.d.ts",
+      "module": "./Match/dist/effect-Match.esm.js",
+      "import": "./Match/dist/effect-Match.cjs.mjs",
+      "default": "./Match/dist/effect-Match.cjs.js"
+    },
     "./Metric": {
       "types": "./dist/declarations/src/Metric.d.ts",
       "module": "./Metric/dist/effect-Metric.esm.js",
@@ -1049,20 +1056,20 @@
     "@changesets/changelog-github": "^0.4.8",
     "@changesets/cli": "^2.26.2",
     "@definitelytyped/dtslint": "^0.0.182",
-    "@effect/build-utils": "^0.1.5",
+    "@effect/build-utils": "^0.1.8",
     "@effect/docgen": "^0.1.8",
     "@effect/eslint-plugin": "^0.1.2",
     "@effect/language-service": "^0.0.21",
     "@preconstruct/cli": "^2.8.1",
     "@types/chai": "^4.3.6",
-    "@types/node": "^20.8.2",
-    "@typescript-eslint/eslint-plugin": "^6.7.4",
-    "@typescript-eslint/parser": "^6.7.4",
+    "@types/node": "^20.8.4",
+    "@typescript-eslint/eslint-plugin": "^6.7.5",
+    "@typescript-eslint/parser": "^6.7.5",
     "@vitejs/plugin-react": "^4.1.0",
     "@vitest/coverage-v8": "^0.34.6",
     "@vitest/expect": "^0.34.6",
     "babel-plugin-annotate-pure-calls": "^0.4.0",
-    "eslint": "^8.50.0",
+    "eslint": "^8.51.0",
     "eslint-import-resolver-typescript": "^3.6.1",
     "eslint-plugin-codegen": "0.17.0",
     "eslint-plugin-deprecation": "^2.0.0",
@@ -1074,7 +1081,7 @@
     "prettier": "^3.0.3",
     "ts-node": "^10.9.1",
     "typescript": "^5.2.2",
-    "vite": "^4.4.10",
+    "vite": "^4.4.11",
     "vitest": "0.34.6"
   },
   "scripts": {
@@ -1087,6 +1094,7 @@
     "circular": "madge --ts-config ./tsconfig.json --circular --no-color --no-spinner --warning src",
     "update-version": "changeset version && pnpm install --no-frozen-lockfile",
     "lint": "eslint src test",
+    "lint-fix": "eslint src test --fix",
     "fix": "preconstruct fix",
     "docgen": "docgen",
     "dtslint": "dtslint --expectOnly dtslint"