effect 3.11.10 → 3.12.1

package/src/internal/metric.ts

@@ -16,7 +16,7 @@ import type * as MetricRegistry from "../MetricRegistry.js"
 import type * as MetricState from "../MetricState.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Cause from "./cause.js"
-import * as _effect from "./core-effect.js"
+import * as effect_ from "./core-effect.js"
 import * as core from "./core.js"
 import * as metricBoundaries from "./metric/boundaries.js"
 import * as metricKey from "./metric/key.js"
@@ -411,7 +411,7 @@ export const trackDefectWith = dual<
   ) => Effect.Effect<A, E, R>
 >(3, (self, metric, f) => {
   const updater = (defect: unknown) => update(metric, f(defect))
-  return _effect.tapDefect(self, (cause) => core.forEachSequentialDiscard(Cause.defects(cause), updater))
+  return effect_.tapDefect(self, (cause) => core.forEachSequentialDiscard(Cause.defects(cause), updater))
 })
 
 /* @internal */
@@ -477,7 +477,7 @@ export const trackErrorWith = dual<
   f: (error: In2) => In
 ) => {
   const updater = (error: E): Effect.Effect<void> => update(metric, f(error))
-  return _effect.tapError(self, updater)
+  return effect_.tapError(self, updater)
 })
 
 /* @internal */

package/src/internal/reloadable.ts

@@ -7,8 +7,8 @@ import type * as Schedule from "../Schedule.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
-import * as _layer from "./layer.js"
-import * as _schedule from "./schedule.js"
+import * as layer_ from "./layer.js"
+import * as schedule_ from "./schedule.js"
 import * as scopedRef from "./scopedRef.js"
 
 /** @internal */
@@ -32,17 +32,17 @@ export const auto = <Out extends Context.Tag<any, any>, E, In, R>(
     readonly schedule: Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
-  _layer.scoped(
+  layer_.scoped(
     reloadableTag(tag),
     pipe(
-      _layer.build(manual(tag, { layer: options.layer })),
+      layer_.build(manual(tag, { layer: options.layer })),
       core.map(Context.unsafeGet(reloadableTag(tag))),
       core.tap((reloadable) =>
         fiberRuntime.acquireRelease(
           pipe(
             reloadable.reload,
             effect.ignoreLogged,
-            _schedule.schedule_Effect(options.schedule),
+            schedule_.schedule_Effect(options.schedule),
             fiberRuntime.forkDaemon
           ),
           core.interruptFiber
@@ -59,13 +59,13 @@ export const autoFromConfig = <Out extends Context.Tag<any, any>, E, In, R>(
     readonly scheduleFromConfig: (context: Context.Context<In>) => Schedule.Schedule<unknown, unknown, R>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, R | In> =>
-  _layer.scoped(
+  layer_.scoped(
     reloadableTag(tag),
     pipe(
       core.context<In>(),
       core.flatMap((env) =>
         pipe(
-          _layer.build(auto(tag, {
+          layer_.build(auto(tag, {
             layer: options.layer,
             schedule: options.scheduleFromConfig(env)
           })),
@@ -91,18 +91,18 @@ export const manual = <Out extends Context.Tag<any, any>, In, E>(
     readonly layer: Layer.Layer<Context.Tag.Identifier<Out>, E, In>
   }
 ): Layer.Layer<Reloadable.Reloadable<Context.Tag.Identifier<Out>>, E, In> =>
-  _layer.scoped(
+  layer_.scoped(
     reloadableTag(tag),
     pipe(
       core.context<In>(),
       core.flatMap((env) =>
         pipe(
-          scopedRef.fromAcquire(pipe(_layer.build(options.layer), core.map(Context.unsafeGet(tag)))),
+          scopedRef.fromAcquire(pipe(layer_.build(options.layer), core.map(Context.unsafeGet(tag)))),
           core.map((ref) => ({
             [ReloadableTypeId]: reloadableVariance,
             scopedRef: ref,
             reload: pipe(
-              scopedRef.set(ref, pipe(_layer.build(options.layer), core.map(Context.unsafeGet(tag)))),
+              scopedRef.set(ref, pipe(layer_.build(options.layer), core.map(Context.unsafeGet(tag)))),
               core.provideContext(env)
             )
           }))

package/src/internal/resource.ts

@@ -6,7 +6,7 @@ import type * as Scope from "../Scope.js"
 import * as core from "./core.js"
 import * as effectable from "./effectable.js"
 import * as fiberRuntime from "./fiberRuntime.js"
-import * as _schedule from "./schedule.js"
+import * as schedule_ from "./schedule.js"
 import * as scopedRef from "./scopedRef.js"
 
 /** @internal */
@@ -42,7 +42,7 @@ export const auto = <A, E, R, Out, R2>(
     fiberRuntime.acquireRelease(
       pipe(
         refresh(manual),
-        _schedule.schedule_Effect(policy),
+        schedule_.schedule_Effect(policy),
         core.interruptible,
         fiberRuntime.forkDaemon
       ),

package/src/internal/runtime.ts

@@ -15,8 +15,8 @@ import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
 import type * as Runtime from "../Runtime.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
-import * as _scheduler from "../Scheduler.js"
-import * as _scope from "../Scope.js"
+import * as scheduler_ from "../Scheduler.js"
+import * as scope_ from "../Scope.js"
 import * as InternalCause from "./cause.js"
 import * as core from "./core.js"
 import * as executionStrategy from "./executionStrategy.js"
@@ -24,7 +24,7 @@ import * as FiberRuntime from "./fiberRuntime.js"
 import * as fiberScope from "./fiberScope.js"
 import * as OpCodes from "./opCodes/effect.js"
 import * as runtimeFlags from "./runtimeFlags.js"
-import * as _supervisor from "./supervisor.js"
+import * as supervisor_ from "./supervisor.js"
 
 /** @internal */
 export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
@@ -38,7 +38,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
   > = [[core.currentContext, [[fiberId, runtime.context]]]]
 
   if (options?.scheduler) {
-    fiberRefUpdates.push([_scheduler.currentScheduler, [[fiberId, options.scheduler]]])
+    fiberRefUpdates.push([scheduler_.currentScheduler, [[fiberId, options.scheduler]]])
   }
 
   let fiberRefs = FiberRefs.updateManyAs(runtime.fiberRefs, {
@@ -60,7 +60,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
 
   if (options?.scope) {
     effect = core.flatMap(
-      _scope.fork(options.scope, executionStrategy.sequential),
+      scope_.fork(options.scope, executionStrategy.sequential),
       (closeableScope) =>
         core.zipRight(
           core.scopeAddFinalizer(
@@ -69,7 +69,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
               equals(id, fiberRuntime.id()) ? core.void : core.interruptAsFiber(fiberRuntime, id)
             )
           ),
-          core.onExit(self, (exit) => _scope.close(closeableScope, exit))
+          core.onExit(self, (exit) => scope_.close(closeableScope, exit))
         )
     )
   }
@@ -77,7 +77,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
   const supervisor = fiberRuntime.currentSupervisor
 
   // we can compare by reference here as _supervisor.none is wrapped with globalValue
-  if (supervisor !== _supervisor.none) {
+  if (supervisor !== supervisor_.none) {
     supervisor.onStart(runtime.context, effect, Option.none(), fiberRuntime)
 
     fiberRuntime.addObserver((exit) => supervisor.onEnd(exit, fiberRuntime))
@@ -243,7 +243,7 @@ export const unsafeRunSyncExit =
     if (op) {
       return op
     }
-    const scheduler = new _scheduler.SyncScheduler()
+    const scheduler = new scheduler_.SyncScheduler()
     const fiberRuntime = unsafeFork(runtime)(effect, { scheduler })
     scheduler.flush()
     const result = fiberRuntime.unsafePoll()

package/src/internal/schedule.ts

@@ -3,6 +3,7 @@ import * as Chunk from "../Chunk.js"
 import * as Clock from "../Clock.js"
 import * as Context from "../Context.js"
 import * as Cron from "../Cron.js"
+import type * as DateTime from "../DateTime.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
 import * as Either from "../Either.js"
@@ -413,8 +414,11 @@ export const mapInputEffect = dual<
     )))
 
 /** @internal */
-export const cron = (expression: string | Cron.Cron): Schedule.Schedule<[number, number]> => {
-  const parsed = Cron.isCron(expression) ? Either.right(expression) : Cron.parse(expression)
+export const cron: {
+  (expression: Cron.Cron): Schedule.Schedule<[number, number]>
+  (expression: string, tz?: DateTime.TimeZone | string): Schedule.Schedule<[number, number]>
+} = (expression: string | Cron.Cron, tz?: DateTime.TimeZone | string): Schedule.Schedule<[number, number]> => {
+  const parsed = Cron.isCron(expression) ? Either.right(expression) : Cron.parse(expression, tz)
   return makeWithState<[boolean, [number, number, number]], unknown, [number, number]>(
     [true, [Number.MIN_SAFE_INTEGER, 0, 0]],
     (now, _, [initial, previous]) => {
@@ -439,8 +443,8 @@ export const cron = (expression: string | Cron.Cron): Schedule.Schedule<[number,
       }
 
       next = Cron.next(cron, date).getTime()
-      const start = beginningOfMinute(next)
-      const end = endOfMinute(next)
+      const start = beginningOfSecond(next)
+      const end = endOfSecond(next)
       return core.succeed([
         [false, [next, start, end]],
         [start, end],

package/src/internal/scopedCache.ts

@@ -15,7 +15,7 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Scope from "../Scope.js"
 import type * as ScopedCache from "../ScopedCache.js"
-import * as _cache from "./cache.js"
+import * as cache_ from "./cache.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
@@ -27,8 +27,8 @@ import * as fiberRuntime from "./fiberRuntime.js"
  */
 export interface CacheState<in out Key, out Value, out Error = never> {
   map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>> // mutable by design
-  keys: _cache.KeySet<Key> // mutable by design
-  accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>> // mutable by design
+  keys: cache_.KeySet<Key> // mutable by design
+  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>> // mutable by design
   updating: MutableRef.MutableRef<boolean> // mutable by design
   hits: number // mutable by design
   misses: number // mutable by design
@@ -37,8 +37,8 @@ export interface CacheState<in out Key, out Value, out Error = never> {
 /** @internal */
 export const makeCacheState = <Key, Value, Error = never>(
   map: MutableHashMap.MutableHashMap<Key, MapValue<Key, Value, Error>>,
-  keys: _cache.KeySet<Key>,
-  accesses: MutableQueue.MutableQueue<_cache.MapKey<Key>>,
+  keys: cache_.KeySet<Key>,
+  accesses: MutableQueue.MutableQueue<cache_.MapKey<Key>>,
   updating: MutableRef.MutableRef<boolean>,
   hits: number,
   misses: number
@@ -59,7 +59,7 @@ export const makeCacheState = <Key, Value, Error = never>(
 export const initialCacheState = <Key, Value, Error = never>(): CacheState<Key, Value, Error> =>
   makeCacheState(
     MutableHashMap.empty(),
-    _cache.makeKeySet(),
+    cache_.makeKeySet(),
     MutableQueue.unbounded(),
     MutableRef.make(false),
     0,
@@ -82,7 +82,7 @@ export type MapValue<Key, Value, Error> =
 /** @internal */
 export interface Complete<out Key, out Value, out Error> {
   readonly _tag: "Complete"
-  readonly key: _cache.MapKey<Key>
+  readonly key: cache_.MapKey<Key>
   readonly exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>
   readonly ownerCount: MutableRef.MutableRef<number>
   readonly entryStats: Cache.EntryStats
@@ -92,7 +92,7 @@ export interface Complete<out Key, out Value, out Error> {
 /** @internal */
 export interface Pending<out Key, out Value, out Error> {
   readonly _tag: "Pending"
-  readonly key: _cache.MapKey<Key>
+  readonly key: cache_.MapKey<Key>
   readonly scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 }
 
@@ -105,7 +105,7 @@ export interface Refreshing<out Key, out Value, out Error> {
 
 /** @internal */
 export const complete = <Key, Value, Error = never>(
-  key: _cache.MapKey<Key>,
+  key: cache_.MapKey<Key>,
   exit: Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
   ownerCount: MutableRef.MutableRef<number>,
   entryStats: Cache.EntryStats,
@@ -122,7 +122,7 @@ export const complete = <Key, Value, Error = never>(
 
 /** @internal */
 export const pending = <Key, Value, Error = never>(
-  key: _cache.MapKey<Key>,
+  key: cache_.MapKey<Key>,
   scoped: Effect.Effect<Effect.Effect<Value, Error, Scope.Scope>>
 ): Pending<Key, Value, Error> =>
   Data.struct({
@@ -206,7 +206,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
 
   get cacheStats(): Effect.Effect<Cache.CacheStats> {
     return core.sync(() =>
-      _cache.makeCacheStats({
+      cache_.makeCacheStats({
         hits: this.cacheState.hits,
         misses: this.cacheState.misses,
         size: MutableHashMap.size(this.cacheState.map)
@@ -245,13 +245,13 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
       }
       switch (value._tag) {
         case "Complete": {
-          return Option.some(_cache.makeEntryStats(value.entryStats.loadedMillis))
+          return Option.some(cache_.makeEntryStats(value.entryStats.loadedMillis))
         }
         case "Pending": {
           return Option.none()
         }
         case "Refreshing": {
-          return Option.some(_cache.makeEntryStats(value.complete.entryStats.loadedMillis))
+          return Option.some(cache_.makeEntryStats(value.complete.entryStats.loadedMillis))
         }
       }
     })
@@ -263,10 +263,10 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
       effect.memoize,
       core.flatMap((lookupValue) =>
         core.suspend(() => {
-          let k: _cache.MapKey<Key> | undefined = undefined
+          let k: cache_.MapKey<Key> | undefined = undefined
           let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
           if (value === undefined) {
-            k = _cache.makeMapKey(key)
+            k = cache_.makeMapKey(key)
             if (MutableHashMap.has(this.cacheState.map, key)) {
               value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
             } else {
@@ -341,9 +341,9 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
       effect.memoize,
       core.flatMap((scoped) => {
         let value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
-        let newKey: _cache.MapKey<Key> | undefined = undefined
+        let newKey: cache_.MapKey<Key> | undefined = undefined
         if (value === undefined) {
-          newKey = _cache.makeMapKey(key)
+          newKey = cache_.makeMapKey(key)
           if (MutableHashMap.has(this.cacheState.map, key)) {
             value = Option.getOrUndefined(MutableHashMap.get(this.cacheState.map, key))
           } else {
@@ -460,10 +460,10 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
               release
             ])
             const completedResult = complete<Key, Value, Error>(
-              _cache.makeMapKey(key),
+              cache_.makeMapKey(key),
               exitWithFinalizer,
               MutableRef.make(1),
-              _cache.makeEntryStats(now),
+              cache_.makeEntryStats(now),
               expiredAt
             )
             let previousValue: MapValue<Key, Value, Error> | undefined = undefined
@@ -482,10 +482,10 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
           }
           case "Failure": {
             const completedResult = complete<Key, Value, Error>(
-              _cache.makeMapKey(key),
+              cache_.makeMapKey(key),
               exit as Exit.Exit<readonly [Value, Scope.Scope.Finalizer], Error>,
               MutableRef.make(0),
-              _cache.makeEntryStats(now),
+              cache_.makeEntryStats(now),
               expiredAt
             )
             let previousValue: MapValue<Key, Value, Error> | undefined = undefined
@@ -524,7 +524,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     this.cacheState.misses = this.cacheState.misses + 1
   }
 
-  trackAccess(key: _cache.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
+  trackAccess(key: cache_.MapKey<Key>): Array<MapValue<Key, Value, Error>> {
     const cleanedKeys: Array<MapValue<Key, Value, Error>> = []
     MutableQueue.offer(this.cacheState.accesses, key)
     if (MutableRef.compareAndSet(this.cacheState.updating, false, true)) {
@@ -575,7 +575,7 @@ class ScopedCacheImpl<in out Key, in out Environment, in out Error, in out Value
     }
   }
 
-  ensureMapSizeNotExceeded(key: _cache.MapKey<Key>): Effect.Effect<void> {
+  ensureMapSizeNotExceeded(key: cache_.MapKey<Key>): Effect.Effect<void> {
     return fiberRuntime.forEachConcurrentDiscard(
       this.trackAccess(key),
       (cleanedMapValue) => this.cleanMapValue(cleanedMapValue),

package/src/internal/stream.ts

@@ -42,7 +42,7 @@ import * as MergeStrategy from "./channel/mergeStrategy.js"
 import * as core from "./core-stream.js"
 import * as doNotation from "./doNotation.js"
 import { RingBuffer } from "./ringBuffer.js"
-import * as _sink from "./sink.js"
+import * as sink_ from "./sink.js"
 import * as DebounceState from "./stream/debounceState.js"
 import * as emit from "./stream/emit.js"
 import * as haltStrategy from "./stream/haltStrategy.js"
@@ -295,7 +295,7 @@ export const aggregateWithinEither = dual<
             Effect.zipRight(
               pipe(
                 handoffConsumer,
-                channel.pipeToOrFail(_sink.toChannel(sink)),
+                channel.pipeToOrFail(sink_.toChannel(sink)),
                 core.collectElements,
                 channel.run,
                 Effect.forkIn(scope)
@@ -424,7 +424,7 @@ export const aggregateWithinEither = dual<
             channel.run,
             Effect.forkIn(scope),
             Effect.zipRight(
-              channel.pipeToOrFail(handoffConsumer, _sink.toChannel(sink)).pipe(
+              channel.pipeToOrFail(handoffConsumer, sink_.toChannel(sink)).pipe(
                 core.collectElements,
                 channel.run,
                 Effect.forkIn(scope),
@@ -3478,7 +3478,7 @@ export const groupedWithin = dual<
     chunkSize: number,
     duration: Duration.DurationInput
   ): Stream.Stream<Chunk.Chunk<A>, E, R> =>
-    aggregateWithin(self, _sink.collectAllN(chunkSize), Schedule.spaced(duration))
+    aggregateWithin(self, sink_.collectAllN(chunkSize), Schedule.spaced(duration))
 )
 
 /** @internal */
@@ -4285,7 +4285,7 @@ export const mergeWith = dual<
 
 /** @internal */
 export const mkString = <E, R>(self: Stream.Stream<string, E, R>): Effect.Effect<string, E, R> =>
-  run(self, _sink.mkString)
+  run(self, sink_.mkString)
 
 /** @internal */
 export const never: Stream.Stream<never> = fromEffect(Effect.never)
@@ -4570,11 +4570,11 @@ export const peel = dual<
       pipe(
         Handoff.make<Signal>(),
         Effect.map((handoff) => {
-          const consumer = _sink.foldSink(_sink.collectLeftover(sink), {
+          const consumer = sink_.foldSink(sink_.collectLeftover(sink), {
             onFailure: (error) =>
-              _sink.zipRight(
-                _sink.fromEffect(Deferred.fail(deferred, error)),
-                _sink.fail(error)
+              sink_.zipRight(
+                sink_.fromEffect(Deferred.fail(deferred, error)),
+                sink_.fail(error)
               ),
             onSuccess: ([z, leftovers]) => {
               const loop: Channel.Channel<Chunk.Chunk<A>, Chunk.Chunk<A>, E | E2, E, void, unknown> = core
@@ -4597,7 +4597,7 @@ export const peel = dual<
                       core.void
                     )
                 })
-              return _sink.fromChannel(
+              return sink_.fromChannel(
                 pipe(
                   core.fromEffect(Deferred.succeed(deferred, z)),
                   channel.zipRight(core.fromEffect(
@@ -4791,7 +4791,7 @@ export const pipeThrough = dual<
     self: Stream.Stream<A, E, R>,
     sink: Sink.Sink<A2, A, L, E2, R2>
   ): Stream.Stream<L, E2 | E, R2 | R> =>
-    new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(_sink.toChannel(sink))))
+    new StreamImpl(pipe(toChannel(self), channel.pipeToOrFail(sink_.toChannel(sink))))
 )
 
 /** @internal */
@@ -5492,20 +5492,20 @@ export const run = dual<
   sink: Sink.Sink<A2, A, unknown, E2, R2>
 ): Effect.Effect<A2, E2 | E, R | R2> =>
   toChannel(self).pipe(
-    channel.pipeToOrFail(_sink.toChannel(sink)),
+    channel.pipeToOrFail(sink_.toChannel(sink)),
     channel.runDrain
   ))
 
 /** @internal */
 export const runCollect = <A, E, R>(
   self: Stream.Stream<A, E, R>
-): Effect.Effect<Chunk.Chunk<A>, E, R> => run(self, _sink.collectAll())
+): Effect.Effect<Chunk.Chunk<A>, E, R> => run(self, sink_.collectAll())
 
 /** @internal */
-export const runCount = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<number, E, R> => run(self, _sink.count)
+export const runCount = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<number, E, R> => run(self, sink_.count)
 
 /** @internal */
-export const runDrain = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<void, E, R> => run(self, _sink.drain)
+export const runDrain = <A, E, R>(self: Stream.Stream<A, E, R>): Effect.Effect<void, E, R> => run(self, sink_.drain)
 
 /** @internal */
 export const runFold = dual<
@@ -5590,7 +5590,7 @@ export const runFoldWhile = dual<
   s: S,
   cont: Predicate<S>,
   f: (s: S, a: A) => S
-): Effect.Effect<S, E, R> => run(self, _sink.fold(s, cont, f)))
+): Effect.Effect<S, E, R> => run(self, sink_.fold(s, cont, f)))
 
 /** @internal */
 export const runFoldWhileEffect = dual<
@@ -5612,7 +5612,7 @@ export const runFoldWhileEffect = dual<
   s: S,
   cont: Predicate<S>,
   f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-): Effect.Effect<S, E2 | E, R | R2> => run(self, _sink.foldEffect(s, cont, f)))
+): Effect.Effect<S, E2 | E, R | R2> => run(self, sink_.foldEffect(s, cont, f)))
 
 /** @internal */
 export const runFoldWhileScoped = dual<
@@ -5632,7 +5632,7 @@ export const runFoldWhileScoped = dual<
   s: S,
   cont: Predicate<S>,
   f: (s: S, a: A) => S
-): Effect.Effect<S, E, Scope.Scope | R> => pipe(self, runScoped(_sink.fold(s, cont, f))))
+): Effect.Effect<S, E, Scope.Scope | R> => pipe(self, runScoped(sink_.fold(s, cont, f))))
 
 /** @internal */
 export const runFoldWhileScopedEffect = dual<
@@ -5652,7 +5652,7 @@ export const runFoldWhileScopedEffect = dual<
   s: S,
   cont: Predicate<S>,
   f: (s: S, a: A) => Effect.Effect<S, E2, R2>
-): Effect.Effect<S, E2 | E, Scope.Scope | R2 | R> => pipe(self, runScoped(_sink.foldEffect(s, cont, f))))
+): Effect.Effect<S, E2 | E, Scope.Scope | R2 | R> => pipe(self, runScoped(sink_.foldEffect(s, cont, f))))
 
 /** @internal */
 export const runForEach = dual<
@@ -5668,7 +5668,7 @@ export const runForEach = dual<
 >(2, <A, E, R, X, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: A) => Effect.Effect<X, E2, R2>
-): Effect.Effect<void, E2 | E, R | R2> => run(self, _sink.forEach(f)))
+): Effect.Effect<void, E2 | E, R | R2> => run(self, sink_.forEach(f)))
 
 /** @internal */
 export const runForEachChunk = dual<
@@ -5684,7 +5684,7 @@ export const runForEachChunk = dual<
 >(2, <A, E, R, X, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-): Effect.Effect<void, E2 | E, R | R2> => run(self, _sink.forEachChunk(f)))
+): Effect.Effect<void, E2 | E, R | R2> => run(self, sink_.forEachChunk(f)))
 
 /** @internal */
 export const runForEachChunkScoped = dual<
@@ -5698,7 +5698,7 @@ export const runForEachChunkScoped = dual<
 >(2, <A, E, R, X, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: Chunk.Chunk<A>) => Effect.Effect<X, E2, R2>
-): Effect.Effect<void, E2 | E, Scope.Scope | R2 | R> => pipe(self, runScoped(_sink.forEachChunk(f))))
+): Effect.Effect<void, E2 | E, Scope.Scope | R2 | R> => pipe(self, runScoped(sink_.forEachChunk(f))))
 
 /** @internal */
 export const runForEachScoped = dual<
@@ -5712,7 +5712,7 @@ export const runForEachScoped = dual<
 >(2, <A, E, R, X, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: A) => Effect.Effect<X, E2, R2>
-): Effect.Effect<void, E2 | E, R2 | R | Scope.Scope> => pipe(self, runScoped(_sink.forEach(f))))
+): Effect.Effect<void, E2 | E, R2 | R | Scope.Scope> => pipe(self, runScoped(sink_.forEach(f))))
 
 /** @internal */
 export const runForEachWhile = dual<
@@ -5728,7 +5728,7 @@ export const runForEachWhile = dual<
 >(2, <A, E, R, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: A) => Effect.Effect<boolean, E2, R2>
-): Effect.Effect<void, E2 | E, R | R2> => run(self, _sink.forEachWhile(f)))
+): Effect.Effect<void, E2 | E, R | R2> => run(self, sink_.forEachWhile(f)))
 
 /** @internal */
 export const runForEachWhileScoped = dual<
@@ -5742,12 +5742,12 @@ export const runForEachWhileScoped = dual<
 >(2, <A, E, R, E2, R2>(
   self: Stream.Stream<A, E, R>,
   f: (a: A) => Effect.Effect<boolean, E2, R2>
-): Effect.Effect<void, E2 | E, R2 | R | Scope.Scope> => pipe(self, runScoped(_sink.forEachWhile(f))))
+): Effect.Effect<void, E2 | E, R2 | R | Scope.Scope> => pipe(self, runScoped(sink_.forEachWhile(f))))
 
 /** @internal */
 export const runHead = <A, E, R>(
   self: Stream.Stream<A, E, R>
-): Effect.Effect<Option.Option<A>, E, R> => run(self, _sink.head<A>())
+): Effect.Effect<Option.Option<A>, E, R> => run(self, sink_.head<A>())
 
 /** @internal */
 export const runIntoPubSub = dual<
@@ -5859,7 +5859,7 @@ export const runIntoQueueScoped = dual<
 /** @internal */
 export const runLast = <A, E, R>(
   self: Stream.Stream<A, E, R>
-): Effect.Effect<Option.Option<A>, E, R> => run(self, _sink.last())
+): Effect.Effect<Option.Option<A>, E, R> => run(self, sink_.last())
 
 /** @internal */
 export const runScoped = dual<
@@ -5876,13 +5876,13 @@ export const runScoped = dual<
 ): Effect.Effect<A2, E | E2, R | R2 | Scope.Scope> =>
   pipe(
     toChannel(self),
-    channel.pipeToOrFail(_sink.toChannel(sink)),
+    channel.pipeToOrFail(sink_.toChannel(sink)),
     channel.drain,
     channel.runScoped
   ))
 
 /** @internal */
-export const runSum = <E, R>(self: Stream.Stream<number, E, R>): Effect.Effect<number, E, R> => run(self, _sink.sum)
+export const runSum = <E, R>(self: Stream.Stream<number, E, R>): Effect.Effect<number, E, R> => run(self, sink_.sum)
 
 /** @internal */
 export const scan = dual<
@@ -7190,7 +7190,7 @@ export const transduce = dual<
         })
       const transducer: Channel.Channel<Chunk.Chunk<A2>, Chunk.Chunk<A>, E | E2, never, void, unknown, R | R2> = pipe(
         sink,
-        _sink.toChannel,
+        sink_.toChannel,
         core.collectElements,
         core.flatMap(([leftover, z]) =>
           pipe(

package/src/internal/subscriptionRef.ts

@@ -8,8 +8,8 @@ import type { Stream } from "../Stream.js"
 import * as Subscribable from "../Subscribable.js"
 import type * as SubscriptionRef from "../SubscriptionRef.js"
 import * as Synchronized from "../SynchronizedRef.js"
-import * as _circular from "./effect/circular.js"
-import * as _ref from "./ref.js"
+import * as circular_ from "./effect/circular.js"
+import * as ref_ from "./ref.js"
 import * as stream from "./stream.js"
 
 /** @internal */
@@ -29,8 +29,8 @@ const subscriptionRefVariance = {
 class SubscriptionRefImpl<in out A> extends Effectable.Class<A> implements SubscriptionRef.SubscriptionRef<A> {
   readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
   readonly [Subscribable.TypeId]: Subscribable.TypeId = Subscribable.TypeId
-  readonly [Ref.RefTypeId] = _ref.refVariance
-  readonly [Synchronized.SynchronizedRefTypeId] = _circular.synchronizedVariance
+  readonly [Ref.RefTypeId] = ref_.refVariance
+  readonly [Synchronized.SynchronizedRefTypeId] = circular_.synchronizedVariance
   readonly [SubscriptionRefTypeId] = subscriptionRefVariance
   constructor(
     readonly ref: Ref.Ref<A>,

package/src/internal/synchronizedRef.ts

@@ -3,7 +3,6 @@ import { dual, pipe } from "../Function.js"
 import * as Option from "../Option.js"
 import type * as Synchronized from "../SynchronizedRef.js"
 import * as core from "./core.js"
-import * as _ref from "./ref.js"
 
 /** @internal */
 export const getAndUpdateEffect = dual<

package/src/internal/tracer.ts

@@ -3,6 +3,7 @@
  */
 import * as Context from "../Context.js"
 import type * as Exit from "../Exit.js"
+import { constFalse } from "../Function.js"
 import type * as Option from "../Option.js"
 import type * as Tracer from "../Tracer.js"
 
@@ -135,3 +136,8 @@ export const addSpanStackTrace = (options: Tracer.SpanOptions | undefined): Trac
     }
   }
 }
+
+/** @internal */
+export const DisablePropagation = Context.Reference<Tracer.DisablePropagation>()("effect/Tracer/DisablePropagation", {
+  defaultValue: constFalse
+})

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.11.10"
+let moduleVersion = "3.12.1"
 
 export const getCurrentVersion = () => moduleVersion