effect 2.4.19 → 3.0.1

package/src/internal/dataSource.ts

@@ -1,13 +1,12 @@
+import * as RA from "../Array.js"
 import * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
 import type * as Context from "../Context.js"
 import * as Effect from "../Effect.js"
 import type * as Either from "../Either.js"
 import { dual, pipe } from "../Function.js"
-import * as RA from "../ReadonlyArray.js"
 import type * as Request from "../Request.js"
 import type * as RequestResolver from "../RequestResolver.js"
-import type { NoInfer } from "../Types.js"
 import * as core from "./core.js"
 import { invokeWithInterrupt, zipWithOptions } from "./fiberRuntime.js"
 import { complete } from "./request.js"
@@ -28,24 +27,24 @@ export const makeBatched = <A extends Request.Request<any, any>, R>(
   run: (requests: Array<A>) => Effect.Effect<void, never, R>
 ): RequestResolver.RequestResolver<A, R> =>
   new core.RequestResolverImpl<A, R>(
-    (requests) =>
-      requests.length > 1 ?
-        core.forEachSequentialDiscard(requests, (block) =>
-          invokeWithInterrupt(
-            run(
-              block
-                .filter((_) => !_.state.completed)
-                .map((_) => _.request)
-            ),
-            block
-          )) :
-        (requests.length === 1 ?
-          run(
-            requests[0]
-              .filter((_) => !_.state.completed)
-              .map((_) => _.request)
-          ) :
-          core.unit)
+    (requests) => {
+      if (requests.length > 1) {
+        return core.forEachSequentialDiscard(requests, (block) => {
+          const filtered = block.filter((_) => !_.state.completed).map((_) => _.request)
+          if (filtered.length === 0) {
+            return core.void
+          }
+          return invokeWithInterrupt(run(filtered), block)
+        })
+      } else if (requests.length === 1) {
+        const filtered = requests[0].filter((_) => !_.state.completed).map((_) => _.request)
+        if (filtered.length === 0) {
+          return core.void
+        }
+        return run(filtered)
+      }
+      return core.void
+    }
   )
 
 /** @internal */

package/src/internal/differ/readonlyArrayPatch.ts

@@ -1,7 +1,7 @@
+import * as Arr from "../../Array.js"
 import type * as Differ from "../../Differ.js"
 import * as Equal from "../../Equal.js"
 import * as Dual from "../../Function.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import * as Data from "../data.js"
 
 /** @internal */
@@ -135,7 +135,7 @@ export const diff = <Value, Patch>(
     patch = combine(patch, makeSlice(0, i))
   }
   if (i < options.newValue.length) {
-    patch = combine(patch, makeAppend(ReadonlyArray.drop(i)(options.newValue)))
+    patch = combine(patch, makeAppend(Arr.drop(i)(options.newValue)))
   }
   return patch
 }
@@ -173,10 +173,10 @@ export const patch = Dual.dual<
     return oldValue
   }
   let readonlyArray = oldValue.slice()
-  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = ReadonlyArray.of(self)
-  while (ReadonlyArray.isNonEmptyArray(patches)) {
-    const head: Instruction = ReadonlyArray.headNonEmpty(patches) as Instruction
-    const tail = ReadonlyArray.tailNonEmpty(patches)
+  let patches: Array<Differ.Differ.ReadonlyArray.Patch<Value, Patch>> = Arr.of(self)
+  while (Arr.isNonEmptyArray(patches)) {
+    const head: Instruction = Arr.headNonEmpty(patches) as Instruction
+    const tail = Arr.tailNonEmpty(patches)
     switch (head._tag) {
       case "Empty": {
         patches = tail

package/src/internal/effect/circular.ts

@@ -289,8 +289,8 @@ export const forkIn = dual<
             child.addFinalizer(() =>
               core.fiberIdWith((fiberId) =>
                 Equal.equals(fiberId, fiber.id()) ?
-                  core.unit :
-                  core.asUnit(core.interruptFiber(fiber))
+                  core.void :
+                  core.asVoid(core.interruptFiber(fiber))
               )
             )
           )

package/src/internal/executionStrategy.ts

@@ -46,27 +46,29 @@ export const isParallelN = (self: ExecutionStrategy.ExecutionStrategy): self is
 
 /** @internal */
 export const match = dual<
-  <A>(
-    onSequential: LazyArg<A>,
-    onParallel: LazyArg<A>,
-    onParallelN: (n: number) => A
-  ) => (self: ExecutionStrategy.ExecutionStrategy) => A,
+  <A>(options: {
+    readonly onSequential: LazyArg<A>
+    readonly onParallel: LazyArg<A>
+    readonly onParallelN: (n: number) => A
+  }) => (self: ExecutionStrategy.ExecutionStrategy) => A,
   <A>(
     self: ExecutionStrategy.ExecutionStrategy,
-    onSequential: LazyArg<A>,
-    onParallel: LazyArg<A>,
-    onParallelN: (n: number) => A
+    options: {
+      readonly onSequential: LazyArg<A>
+      readonly onParallel: LazyArg<A>
+      readonly onParallelN: (n: number) => A
+    }
   ) => A
->(4, (self, onSequential, onParallel, onParallelN) => {
+>(2, (self, options) => {
   switch (self._tag) {
     case OP_SEQUENTIAL: {
-      return onSequential()
+      return options.onSequential()
     }
     case OP_PARALLEL: {
-      return onParallel()
+      return options.onParallel()
     }
     case OP_PARALLEL_N: {
-      return onParallelN(self.parallelism)
+      return options.onParallelN(self.parallelism)
     }
   }
 })

package/src/internal/fiber.ts

@@ -81,9 +81,9 @@ export const done = <A, E>(exit: Exit.Exit<A, E>): Fiber.Fiber<A, E> => ({
   id: () => FiberId.none,
   await: core.succeed(exit),
   children: core.succeed([]),
-  inheritAll: core.unit,
+  inheritAll: core.void,
   poll: core.succeed(Option.some(exit)),
-  interruptAsFork: () => core.unit
+  interruptAsFork: () => core.void
 })
 
 /** @internal */
@@ -254,7 +254,7 @@ export const orElse = dual<
     pipe(
       core.interruptAsFiber(self, id),
       core.zipRight(pipe(that, core.interruptAsFiber(id))),
-      core.asUnit
+      core.asVoid
     )
 }))
 
@@ -334,8 +334,11 @@ export const status = <A, E>(self: Fiber.RuntimeFiber<A, E>): Effect.Effect<Fibe
 /** @internal */
 export const succeed = <A>(value: A): Fiber.Fiber<A> => done(Exit.succeed(value))
 
-/** @internal */
-export const unit: Fiber.Fiber<void> = succeed(void 0)
+const void_: Fiber.Fiber<void> = succeed(void 0)
+export {
+  /** @internal */
+  void_ as void
+}
 
 /** @internal */
 export const currentFiberURI = "effect/FiberCurrent"

package/src/internal/fiberRefs/patch.ts

@@ -1,9 +1,9 @@
+import * as Arr from "../../Array.js"
 import { equals } from "../../Equal.js"
 import type * as FiberId from "../../FiberId.js"
 import type * as FiberRefs from "../../FiberRefs.js"
 import type * as FiberRefsPatch from "../../FiberRefsPatch.js"
 import { dual } from "../../Function.js"
-import * as Arr from "../../ReadonlyArray.js"
 import * as _fiberRefs from "../fiberRefs.js"
 
 /** @internal */

package/src/internal/fiberRefs.ts

@@ -1,3 +1,4 @@
+import * as Arr from "../Array.js"
 import type * as Effect from "../Effect.js"
 import * as Equal from "../Equal.js"
 import type * as FiberId from "../FiberId.js"
@@ -7,7 +8,6 @@ import { dual, pipe } from "../Function.js"
 import * as HashSet from "../HashSet.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
-import * as Arr from "../ReadonlyArray.js"
 import * as core from "./core.js"
 
 /** @internal */

package/src/internal/fiberRuntime.ts

@@ -1,3 +1,4 @@
+import * as RA from "../Array.js"
 import * as Boolean from "../Boolean.js"
 import type * as Cause from "../Cause.js"
 import * as Chunk from "../Chunk.js"
@@ -31,7 +32,6 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
 import type * as Random from "../Random.js"
-import * as RA from "../ReadonlyArray.js"
 import * as Ref from "../Ref.js"
 import type { Entry, Request } from "../Request.js"
 import type * as RequestBlock from "../RequestBlock.js"
@@ -41,7 +41,7 @@ import { currentScheduler, type Scheduler } from "../Scheduler.js"
 import type * as Scope from "../Scope.js"
 import type * as Supervisor from "../Supervisor.js"
 import type * as Tracer from "../Tracer.js"
-import type { Concurrency, NoInfer } from "../Types.js"
+import type { Concurrency } from "../Types.js"
 import * as _RequestBlock from "./blockedRequests.js"
 import * as internalCause from "./cause.js"
 import * as clock from "./clock.js"
@@ -184,7 +184,7 @@ const contOpSuccess = {
       self.pushStack(cont)
       return cont.effect_instruction_i1()
     } else {
-      return core.unit
+      return core.void
     }
   }
 }
@@ -743,7 +743,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
       const body = () => {
         const next = it.next()
         if (!next.done) {
-          return core.asUnit(next.value.await)
+          return core.asVoid(next.value.await)
         } else {
           return core.sync(() => {
             isDone = true
@@ -895,10 +895,10 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
           if (op._op === OpCodes.OP_YIELD) {
             if (_runtimeFlags.cooperativeYielding(this._runtimeFlags)) {
               this.tell(FiberMessage.yieldNow())
-              this.tell(FiberMessage.resume(core.exitUnit))
+              this.tell(FiberMessage.resume(core.exitVoid))
               effect = null
             } else {
-              effect = core.exitUnit
+              effect = core.exitVoid
             }
           } else if (op._op === OpCodes.OP_ASYNC) {
             // Terminate this evaluation, async resumption will continue evaluation:
@@ -1209,7 +1209,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
         this.pushStack(new core.RevertFlags(revertFlags, op))
         return op.effect_instruction_i1(oldRuntimeFlags)
       } else {
-        return core.exitUnit
+        return core.exitVoid
       }
     }
   }
@@ -1254,7 +1254,7 @@ export class FiberRuntime<in out A, in out E = never> implements Fiber.RuntimeFi
       this.pushStack(op)
       return body()
     } else {
-      return core.exitUnit
+      return core.exitVoid
     }
   }
 
@@ -1477,7 +1477,7 @@ export const batchedLogger = dual<
     let buffer: Array<Output> = []
     const flush = core.suspend(() => {
       if (buffer.length === 0) {
-        return core.unit
+        return core.void
       }
       const arr = buffer
       buffer = []
@@ -1597,7 +1597,7 @@ export const exists: {
         core.matchEffect(
           forEach(
             elements,
-            (a, i) => core.if_(f(a, i), { onTrue: core.fail(_existsParFound), onFalse: core.unit }),
+            (a, i) => core.if_(f(a, i), { onTrue: () => core.fail(_existsParFound), onFalse: () => core.void }),
             options
           ),
           {
@@ -1735,7 +1735,7 @@ const allValidate = (
           core.fail(reconcile.value(errors)) :
           core.fail(errors)
       } else if (options?.discard) {
-        return core.unit
+        return core.void
       }
       return reconcile._tag === "Some" ?
         core.succeed(reconcile.value(successes)) :
@@ -1996,7 +1996,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
         let todos = Array.from(self).reverse()
         let target = todos.length
         if (target === 0) {
-          return core.unit
+          return core.void
         }
         let counter = 0
         let interrupted = false
@@ -2018,7 +2018,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
             .sort((a, b) => a.index < b.index ? -1 : a.index === b.index ? 0 : 1)
             .map(({ exit }) => exit)
           if (exits.length === 0) {
-            exits.push(core.exitUnit)
+            exits.push(core.exitVoid)
           }
           return exits
         }
@@ -2108,7 +2108,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                   if (results.length === target) {
                     resume(core.succeed(Option.getOrElse(
                       core.exitCollectAll(collectExits(), { parallel: true }),
-                      () => core.exitUnit
+                      () => core.exitVoid
                     )))
                   } else if (residual.length + results.length === target) {
                     const requests = residual.map((blocked) => blocked.effect_instruction_i0).reduce(_RequestBlock.par)
@@ -2118,7 +2118,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
                         [
                           Option.getOrElse(
                             core.exitCollectAll(collectExits(), { parallel: true }),
-                            () => core.exitUnit
+                            () => core.exitVoid
                           ),
                           ...residual.map((blocked) => blocked.effect_instruction_i1)
                         ],
@@ -2139,7 +2139,7 @@ export const forEachConcurrentDiscard = <A, X, E, R>(
             }
           })
         )
-        return core.asUnit(
+        return core.asVoid(
           core.onExit(
             core.flatten(restore(internalFiber.join(processingFiber))),
             core.exitMatch({
@@ -2413,7 +2413,7 @@ export const validateAll = dual<
       }),
       ([es, bs]) =>
         es.length === 0
-          ? options?.discard ? core.unit : core.succeed(bs)
+          ? options?.discard ? core.void : core.succeed(bs)
           : core.fail(es)
     )
 )
@@ -2455,7 +2455,7 @@ export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
                   core.tap((fibers) =>
                     pipe(
                       fibers,
-                      RA.reduce(core.unit, (effect, fiber) =>
+                      RA.reduce(core.void, (effect, fiber) =>
                         pipe(
                           effect,
                           core.zipRight(
@@ -2463,7 +2463,7 @@ export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
                               internalFiber._await(fiber),
                               core.flatMap(raceAllArbiter(fibers, fiber, done, fails)),
                               fork,
-                              core.asUnit
+                              core.asVoid
                             )
                           )
                         ))
@@ -2476,7 +2476,7 @@ export const raceAll: <Eff extends Effect.Effect<any, any, any>>(
                         pipe(
                           fibers,
                           RA.reduce(
-                            core.unit,
+                            core.void,
                             (effect, fiber) => pipe(effect, core.zipLeft(core.interruptFiber(fiber)))
                           )
                         )
@@ -2506,8 +2506,8 @@ const raceAllArbiter = <E, E1, A, A1>(
         Ref.modify(fails, (fails) =>
           [
             fails === 0 ?
-              pipe(core.deferredFailCause(deferred, cause), core.asUnit) :
-              core.unit,
+              pipe(core.deferredFailCause(deferred, cause), core.asVoid) :
+              core.void,
             fails - 1
           ] as const),
         core.flatten
@@ -2520,14 +2520,14 @@ const raceAllArbiter = <E, E1, A, A1>(
             pipe(
               Chunk.fromIterable(fibers),
               RA.reduce(
-                core.unit,
+                core.void,
                 (effect, fiber) =>
                   fiber === winner ?
                     effect :
                     pipe(effect, core.zipLeft(core.interruptFiber(fiber)))
               )
             ) :
-            core.unit
+            core.void
         )
       )
   })
@@ -2798,7 +2798,7 @@ export const validateAllParDiscard = dual<
     partition(elements, f),
     ([es, _]) =>
       es.length === 0
-        ? core.unit
+        ? core.void
         : core.fail(es)
   ))
 
@@ -2971,7 +2971,7 @@ export const withRuntimeFlagsScoped = (
   update: RuntimeFlagsPatch.RuntimeFlagsPatch
 ): Effect.Effect<void, never, Scope.Scope> => {
   if (update === RuntimeFlagsPatch.empty) {
-    return core.unit
+    return core.void
   }
   return pipe(
     core.runtimeFlags,
@@ -2981,7 +2981,7 @@ export const withRuntimeFlagsScoped = (
       return pipe(
         core.updateRuntimeFlags(update),
         core.zipRight(addFinalizer(() => core.updateRuntimeFlags(revertRuntimeFlags))),
-        core.asUnit
+        core.asVoid
       )
     }),
     core.uninterruptible
@@ -3039,12 +3039,12 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
   close(this: ScopeImpl, exit) {
     return core.suspend(() => {
       if (this.state._tag === "Closed") {
-        return core.unit
+        return core.void
       }
       const finalizers = Array.from(this.state.finalizers.values()).reverse()
       this.state = { _tag: "Closed", exit }
       if (finalizers.length === 0) {
-        return core.unit
+        return core.void
       }
       return executionStrategy.isSequential(this.strategy) ?
         pipe(
@@ -3052,8 +3052,8 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
           core.flatMap((results) =>
             pipe(
               core.exitCollectAll(results),
-              Option.map(core.exitAsUnit),
-              Option.getOrElse(() => core.exitUnit)
+              Option.map(core.exitAsVoid),
+              Option.getOrElse(() => core.exitVoid)
             )
           )
         ) :
@@ -3063,8 +3063,8 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
           core.flatMap((results) =>
             pipe(
               core.exitCollectAll(results, { parallel: true }),
-              Option.map(core.exitAsUnit),
-              Option.getOrElse(() => core.exitUnit)
+              Option.map(core.exitAsVoid),
+              Option.getOrElse(() => core.exitVoid)
             )
           )
         ) :
@@ -3073,8 +3073,8 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
           core.flatMap((results) =>
             pipe(
               core.exitCollectAll(results, { parallel: true }),
-              Option.map(core.exitAsUnit),
-              Option.getOrElse(() => core.exitUnit)
+              Option.map(core.exitAsVoid),
+              Option.getOrElse(() => core.exitVoid)
             )
           )
         )
@@ -3086,7 +3086,7 @@ const ScopeImplProto: Omit<ScopeImpl, "strategy" | "state"> = {
         return fin(this.state.exit)
       }
       this.state.finalizers.add(fin)
-      return core.unit
+      return core.void
     })
   }
 }
@@ -3153,7 +3153,7 @@ export const fiberRefLocallyScoped = dual<
   <A>(value: A) => (self: FiberRef.FiberRef<A>) => Effect.Effect<void, never, Scope.Scope>,
   <A>(self: FiberRef.FiberRef<A>, value: A) => Effect.Effect<void, never, Scope.Scope>
 >(2, (self, value) =>
-  core.asUnit(
+  core.asVoid(
     acquireRelease(
       core.flatMap(
         core.fiberRefGet(self),
@@ -3214,7 +3214,7 @@ export const currentSupervisor: FiberRef.FiberRef<Supervisor.Supervisor<any>> =
 
 /* @internal */
 export const fiberAwaitAll = (fibers: Iterable<Fiber.Fiber<any, any>>): Effect.Effect<void> =>
-  core.asUnit(internalFiber._await(fiberAll(fibers)))
+  core.asVoid(internalFiber._await(fiberAll(fibers)))
 
 /** @internal */
 export const fiberAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Fiber.Fiber<Array<A>, E> => ({
@@ -3260,11 +3260,11 @@ export const fiberAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Fiber.Fiber
 
 /* @internal */
 export const fiberInterruptFork = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<void> =>
-  core.asUnit(forkDaemon(core.interruptFiber(self)))
+  core.asVoid(forkDaemon(core.interruptFiber(self)))
 
 /* @internal */
-export const fiberJoinAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<void, E> =>
-  core.asUnit(internalFiber.join(fiberAll(fibers)))
+export const fiberJoinAll = <A, E>(fibers: Iterable<Fiber.Fiber<A, E>>): Effect.Effect<Array<A>, E> =>
+  internalFiber.join(fiberAll(fibers))
 
 /* @internal */
 export const fiberScoped = <A, E>(self: Fiber.Fiber<A, E>): Effect.Effect<Fiber.Fiber<A, E>, never, Scope.Scope> =>
@@ -3573,10 +3573,10 @@ export const makeSpanScoped = (
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
-  }
+  } | undefined
 ): Effect.Effect<Tracer.Span, never, Scope.Scope> =>
   core.uninterruptible(
     core.withFiberRuntime((fiber) => {
@@ -3606,14 +3606,14 @@ export const withSpanScoped = dual<
   (name: string, options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }) => <A, E, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>,
   <A, E, R>(self: Effect.Effect<A, E, R>, name: string, options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
   }) => Effect.Effect<A, E, Exclude<R, Tracer.ParentSpan> | Scope.Scope>

package/src/internal/groupBy.ts

@@ -13,7 +13,7 @@ import * as Queue from "../Queue.js"
 import * as Ref from "../Ref.js"
 import type * as Stream from "../Stream.js"
 import type * as Take from "../Take.js"
-import type { MergeRecord, NoInfer } from "../Types.js"
+import type { MergeRecord } from "../Types.js"
 import * as channel from "./channel.js"
 import * as channelExecutor from "./channel/channelExecutor.js"
 import * as core from "./core-stream.js"
@@ -442,7 +442,7 @@ export const groupByKey = dual<
                             Queue.offer(innerQueue, take.chunk(values)),
                             Effect.catchSomeCause((cause) =>
                               Cause.isInterruptedOnly(cause) ?
-                                Option.some(Effect.unit) :
+                                Option.some(Effect.void) :
                                 Option.none()
                             )
                           )
@@ -455,7 +455,7 @@ export const groupByKey = dual<
                   Queue.offer(innerQueue, take.chunk(values)),
                   (cause) =>
                     Cause.isInterruptedOnly(cause) ?
-                      Option.some(Effect.unit) :
+                      Option.some(Effect.void) :
                       Option.none()
                 )
               }, { discard: true })
@@ -472,7 +472,7 @@ export const groupByKey = dual<
                     Queue.offer(innerQueue, take.end),
                     Effect.catchSomeCause((cause) =>
                       Cause.isInterruptedOnly(cause) ?
-                        Option.some(Effect.unit) :
+                        Option.some(Effect.void) :
                         Option.none()
                     )
                   ), { discard: true }),

package/src/internal/hashMap.ts

@@ -7,7 +7,6 @@ import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
-import type { NoInfer } from "../Types.js"
 import { fromBitmap, hashFragment, toBitmap } from "./hashMap/bitwise.js"
 import { SIZE } from "./hashMap/config.js"
 import * as Node from "./hashMap/node.js"

package/src/internal/hashSet.ts

@@ -7,7 +7,6 @@ import { format, NodeInspectSymbol, toJSON } from "../Inspectable.js"
 import { pipeArguments } from "../Pipeable.js"
 import type { Predicate, Refinement } from "../Predicate.js"
 import { hasProperty } from "../Predicate.js"
-import type { NoInfer } from "../Types.js"
 import * as HM from "./hashMap.js"
 
 const HashSetSymbolKey = "effect/HashSet"

package/src/internal/layer/circular.ts

@@ -185,7 +185,7 @@ export const setConfigProvider = (configProvider: ConfigProvider.ConfigProvider)
   layer.scopedDiscard(fiberRuntime.withConfigProviderScoped(configProvider))
 
 /** @internal */
-export const parentSpan = (span: Tracer.ParentSpan): Layer.Layer<Tracer.ParentSpan> =>
+export const parentSpan = (span: Tracer.AnySpan): Layer.Layer<Tracer.ParentSpan> =>
   layer.succeedContext(Context.make(tracer.spanTag, span))
 
 /** @internal */
@@ -194,7 +194,7 @@ export const span = (
   options?: {
     readonly attributes?: Record<string, unknown> | undefined
     readonly links?: ReadonlyArray<Tracer.SpanLink> | undefined
-    readonly parent?: Tracer.ParentSpan | undefined
+    readonly parent?: Tracer.AnySpan | undefined
     readonly root?: boolean | undefined
     readonly context?: Context.Context<never> | undefined
     readonly onEnd?: