effect 2.4.19 → 3.0.0

package/src/internal/metric/hook.ts

@@ -1,3 +1,4 @@
+import * as Array from "../../Array.js"
 import * as Duration from "../../Duration.js"
 import type { LazyArg } from "../../Function.js"
 import { dual, pipe } from "../../Function.js"
@@ -7,7 +8,6 @@ import type * as MetricState from "../../MetricState.js"
 import * as number from "../../Number.js"
 import * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import * as metricState from "./state.js"
 
 /** @internal */
@@ -78,8 +78,11 @@ export const counter = <A extends (number | bigint)>(
 }
 
 /** @internal */
-export const frequency = (_key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency => {
+export const frequency = (key: MetricKey.MetricKey.Frequency): MetricHook.MetricHook.Frequency => {
   const values = new Map<string, number>()
+  for (const word of key.keyType.preregisteredWords) {
+    values.set(word, 0)
+  }
   const update = (word: string) => {
     const slotCount = values.get(word) ?? 0
     values.set(word, slotCount + 1)
@@ -120,8 +123,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
 
   pipe(
     bounds,
-    ReadonlyArray.sort(number.Order),
-    ReadonlyArray.map((n, i) => {
+    Array.sort(number.Order),
+    Array.map((n, i) => {
       boundaries[i] = n
     })
   )
@@ -159,7 +162,7 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
   }
 
   const getBuckets = (): ReadonlyArray<readonly [number, number]> => {
-    const builder: Array<readonly [number, number]> = Array(size)
+    const builder: Array<readonly [number, number]> = Array.allocate(size) as any
     let cumulated = 0
     for (let i = 0; i < size; i++) {
       const boundary = boundaries[i]
@@ -186,8 +189,8 @@ export const histogram = (key: MetricKey.MetricKey.Histogram): MetricHook.Metric
 /** @internal */
 export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook.Summary => {
   const { error, maxAge, maxSize, quantiles } = key.keyType
-  const sortedQuantiles = pipe(quantiles, ReadonlyArray.sort(number.Order))
-  const values = Array<readonly [number, number]>(maxSize)
+  const sortedQuantiles = pipe(quantiles, Array.sort(number.Order))
+  const values = Array.allocate<readonly [number, number]>(maxSize)
 
   let head = 0
   let count = 0
@@ -225,7 +228,7 @@ export const summary = (key: MetricKey.MetricKey.Summary): MetricHook.MetricHook
     return calculateQuantiles(
       error,
       sortedQuantiles,
-      ReadonlyArray.sort(builder, number.Order)
+      Array.sort(builder, number.Order)
     )
   }
 
@@ -288,8 +291,8 @@ const calculateQuantiles = (
 ): ReadonlyArray<readonly [number, Option.Option<number>]> => {
   // The number of samples examined
   const sampleCount = sortedSamples.length
-  if (!ReadonlyArray.isNonEmptyReadonlyArray(sortedQuantiles)) {
-    return ReadonlyArray.empty()
+  if (!Array.isNonEmptyReadonlyArray(sortedQuantiles)) {
+    return Array.empty()
   }
   const head = sortedQuantiles[0]
   const tail = sortedQuantiles.slice(1)
@@ -301,7 +304,7 @@ const calculateQuantiles = (
     head,
     sortedSamples
   )
-  const resolved = ReadonlyArray.of(resolvedHead)
+  const resolved = Array.of(resolvedHead)
   tail.forEach((quantile) => {
     resolved.push(
       resolveQuantile(
@@ -314,7 +317,7 @@ const calculateQuantiles = (
       )
     )
   })
-  return ReadonlyArray.map(resolved, (rq) => [rq.quantile, rq.value] as const)
+  return Array.map(resolved, (rq) => [rq.quantile, rq.value] as const)
 }
 
 /** @internal */
@@ -341,7 +344,7 @@ const resolveQuantile = (
   // eslint-disable-next-line no-constant-condition
   while (1) {
     // If the remaining list of samples is empty, there is nothing more to resolve
-    if (!ReadonlyArray.isNonEmptyReadonlyArray(rest_1)) {
+    if (!Array.isNonEmptyReadonlyArray(rest_1)) {
       return {
         quantile: quantile_1,
         value: Option.none(),
@@ -354,14 +357,14 @@ const resolveQuantile = (
     if (quantile_1 === 1) {
       return {
         quantile: quantile_1,
-        value: Option.some(ReadonlyArray.lastNonEmpty(rest_1)),
+        value: Option.some(Array.lastNonEmpty(rest_1)),
         consumed: consumed_1 + rest_1.length,
         rest: []
       }
     }
     // Split into two chunks - the first chunk contains all elements of the same
     // value as the chunk head
-    const sameHead = ReadonlyArray.span(rest_1, (n) => n <= rest_1[0])
+    const sameHead = Array.span(rest_1, (n) => n <= rest_1[0])
     // How many elements do we want to accept for this quantile
     const desired = quantile_1 * sampleCount_1
     // The error margin
@@ -375,7 +378,7 @@ const resolveQuantile = (
     if (candConsumed < desired - allowedError) {
       error_2 = error_1
       sampleCount_2 = sampleCount_1
-      current_2 = ReadonlyArray.head(rest_1)
+      current_2 = Array.head(rest_1)
       consumed_2 = candConsumed
       quantile_2 = quantile_1
       rest_2 = sameHead[1]
@@ -403,7 +406,7 @@ const resolveQuantile = (
       case "None": {
         error_2 = error_1
         sampleCount_2 = sampleCount_1
-        current_2 = ReadonlyArray.head(rest_1)
+        current_2 = Array.head(rest_1)
         consumed_2 = candConsumed
         quantile_2 = quantile_1
         rest_2 = sameHead[1]
@@ -420,7 +423,7 @@ const resolveQuantile = (
         if (candError < prevError) {
           error_2 = error_1
           sampleCount_2 = sampleCount_1
-          current_2 = ReadonlyArray.head(rest_1)
+          current_2 = Array.head(rest_1)
           consumed_2 = candConsumed
           quantile_2 = quantile_1
           rest_2 = sameHead[1]

package/src/internal/metric/key.ts

@@ -1,3 +1,4 @@
+import * as Array from "../../Array.js"
 import type * as Duration from "../../Duration.js"
 import * as Equal from "../../Equal.js"
 import { dual, pipe } from "../../Function.js"
@@ -9,7 +10,6 @@ import type * as MetricLabel from "../../MetricLabel.js"
 import * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import * as metricKeyType from "./keyType.js"
 import * as metricLabel from "./label.js"
 
@@ -26,7 +26,7 @@ const metricKeyVariance = {
   _Type: (_: never) => _
 }
 
-const arrayEquivilence = ReadonlyArray.getEquivalence(Equal.equals)
+const arrayEquivilence = Array.getEquivalence(Equal.equals)
 
 /** @internal */
 class MetricKeyImpl<out Type extends MetricKeyType.MetricKeyType<any, any>> implements MetricKey.MetricKey<Type> {
@@ -83,8 +83,11 @@ export const counter: {
   )
 
 /** @internal */
-export const frequency = (name: string, description?: string): MetricKey.MetricKey.Frequency =>
-  new MetricKeyImpl(name, metricKeyType.frequency, Option.fromNullable(description))
+export const frequency = (name: string, options?: {
+  readonly description?: string | undefined
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKey.MetricKey.Frequency =>
+  new MetricKeyImpl(name, metricKeyType.frequency(options), Option.fromNullable(options?.description))
 
 /** @internal */
 export const gauge: {
@@ -161,4 +164,4 @@ export const taggedWithLabels = dual<
 >(2, (self, extraTags) =>
   extraTags.length === 0
     ? self
-    : new MetricKeyImpl(self.name, self.keyType, self.description, ReadonlyArray.union(self.tags, extraTags)))
+    : new MetricKeyImpl(self.name, self.keyType, self.description, Array.union(self.tags, extraTags)))

package/src/internal/metric/keyType.ts

@@ -86,7 +86,8 @@ const FrequencyKeyTypeHash = Hash.string(FrequencyKeyTypeSymbolKey)
 /** @internal */
 class FrequencyKeyType implements MetricKeyType.MetricKeyType.Frequency {
   readonly [MetricKeyTypeTypeId] = metricKeyTypeVariance
-  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId;
+  readonly [FrequencyKeyTypeTypeId]: MetricKeyType.FrequencyKeyTypeTypeId = FrequencyKeyTypeTypeId
+  constructor(readonly preregisteredWords: ReadonlyArray<string>) {}
   [Hash.symbol](): number {
     return FrequencyKeyTypeHash
   }
@@ -192,7 +193,9 @@ export const counter: <A extends number | bigint>(options?: {
  * @since 2.0.0
  * @category constructors
  */
-export const frequency: MetricKeyType.MetricKeyType.Frequency = new FrequencyKeyType()
+export const frequency = (options?: {
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): MetricKeyType.MetricKeyType.Frequency => new FrequencyKeyType(options?.preregisteredWords ?? [])
 
 /**
  * @since 2.0.0

package/src/internal/metric/state.ts

@@ -1,3 +1,4 @@
+import * as Array from "../../Array.js"
 import * as Equal from "../../Equal.js"
 import { pipe } from "../../Function.js"
 import * as Hash from "../../Hash.js"
@@ -5,7 +6,6 @@ import type * as MetricState from "../../MetricState.js"
 import type * as Option from "../../Option.js"
 import { pipeArguments } from "../../Pipeable.js"
 import { hasProperty } from "../../Predicate.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 
 /** @internal */
 const MetricStateSymbolKey = "effect/MetricState"
@@ -80,7 +80,7 @@ class CounterState<A extends (number | bigint)> implements MetricState.MetricSta
   }
 }
 
-const arrayEquals = ReadonlyArray.getEquivalence(Equal.equals)
+const arrayEquals = Array.getEquivalence(Equal.equals)
 
 /** @internal */
 class FrequencyState implements MetricState.MetricState.Frequency {
@@ -91,14 +91,14 @@ class FrequencyState implements MetricState.MetricState.Frequency {
   [Hash.symbol](): number {
     return pipe(
       Hash.string(FrequencyStateSymbolKey),
-      Hash.combine(Hash.array(ReadonlyArray.fromIterable(this.occurrences.entries()))),
+      Hash.combine(Hash.array(Array.fromIterable(this.occurrences.entries()))),
       Hash.cached(this)
     )
   }
   [Equal.symbol](that: unknown): boolean {
     return isFrequencyState(that) && arrayEquals(
-      ReadonlyArray.fromIterable(this.occurrences.entries()),
-      ReadonlyArray.fromIterable(that.occurrences.entries())
+      Array.fromIterable(this.occurrences.entries()),
+      Array.fromIterable(that.occurrences.entries())
     )
   }
   pipe() {

package/src/internal/metric.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import * as Clock from "../Clock.js"
 import * as Duration from "../Duration.js"
 import type * as Effect from "../Effect.js"
@@ -14,7 +15,6 @@ import type * as MetricPair from "../MetricPair.js"
 import type * as MetricRegistry from "../MetricRegistry.js"
 import type * as MetricState from "../MetricState.js"
 import { pipeArguments } from "../Pipeable.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as Cause from "./cause.js"
 import * as _effect from "./core-effect.js"
 import * as core from "./core.js"
@@ -98,8 +98,10 @@ export const counter: {
 } = (name, options) => fromMetricKey(metricKey.counter(name, options as any)) as any
 
 /** @internal */
-export const frequency = (name: string, description?: string): Metric.Metric.Frequency<string> =>
-  fromMetricKey(metricKey.frequency(name, description))
+export const frequency = (name: string, options?: {
+  readonly description?: string | undefined
+  readonly preregisteredWords?: ReadonlyArray<string> | undefined
+}): Metric.Metric.Frequency<string> => fromMetricKey(metricKey.frequency(name, options))
 
 /** @internal */
 export const withConstantInput = dual<
@@ -273,7 +275,7 @@ export const taggedWithLabelsInput = dual<
       (input, extraTags) =>
         self.unsafeUpdate(
           input,
-          ReadonlyArray.union(f(input), extraTags)
+          Array.union(f(input), extraTags)
         ),
       self.unsafeValue
     ),
@@ -292,8 +294,8 @@ export const taggedWithLabels = dual<
 >(2, (self, extraTags) => {
   return make(
     self.keyType,
-    (input, extraTags1) => self.unsafeUpdate(input, ReadonlyArray.union(extraTags, extraTags1)),
-    (extraTags1) => self.unsafeValue(ReadonlyArray.union(extraTags, extraTags1))
+    (input, extraTags1) => self.unsafeUpdate(input, Array.union(extraTags, extraTags1)),
+    (extraTags1) => self.unsafeValue(Array.union(extraTags, extraTags1))
   )
 })
 

package/src/internal/pool.ts

@@ -75,13 +75,13 @@ interface Strategy<S, R, E, A> {
  */
 class NoneStrategy implements Strategy<unknown, never, never, never> {
   initial(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
   track(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
   run(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 }
 
@@ -100,7 +100,7 @@ class TimeToLiveStrategy implements Strategy<readonly [Clock.Clock, Ref.Ref<numb
         )))
   }
   track(state: readonly [Clock.Clock, Ref.Ref<number>]): Effect.Effect<void> {
-    return core.asUnit(core.flatMap(
+    return core.asVoid(core.flatMap(
       state[0].currentTimeMillis,
       (now) => ref.set(state[1], now)
     ))
@@ -222,7 +222,7 @@ class PoolImpl<in out A, in out E> implements Pool.Pool<A, E> {
             if (state.size <= this.min) {
               return [allocateUinterruptible(this), { ...state, free: state.free + 1 }] as const
             }
-            return [core.unit, { ...state, size: state.size - 1 }] as const
+            return [core.void, { ...state, size: state.size - 1 }] as const
           })),
         onSuccess: (item) =>
           core.flatMap(ref.get(this.invalidated), (set) => {
@@ -303,7 +303,7 @@ const finalizeInvalid = <A, E>(
         if (state.size <= self.min) {
           return [allocateUinterruptible(self), { ...state, free: state.free + 1 }] as const
         }
-        return [core.unit, { ...state, size: state.size - 1 }] as const
+        return [core.void, { ...state, size: state.size - 1 }] as const
       }))
     )
   )
@@ -317,7 +317,7 @@ const getAndShutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
     if (state.free > 0) {
       return [
         core.matchCauseEffect(queue.take(self.items), {
-          onFailure: () => core.unit,
+          onFailure: () => core.void,
           onSuccess: (attempted) =>
             pipe(
               forEach(attempted, (a) => ref.update(self.invalidated, HashSet.remove(a))),
@@ -330,7 +330,7 @@ const getAndShutdown = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
       ] as const
     }
     if (state.size > 0) {
-      return [core.unit, state] as const
+      return [core.void, state] as const
     }
     return [queue.shutdown(self.items), { ...state, size: state.size - 1 }] as const
   }))
@@ -348,7 +348,7 @@ const initialize = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
             { size: state.size + 1, free: state.free + 1 }
           ] as const
         }
-        return [core.unit, state] as const
+        return [core.void, state] as const
       }))
     ),
     self.min,
@@ -376,7 +376,7 @@ const shrink = <A, E>(self: PoolImpl<A, E>): Effect.Effect<void> =>
           { ...state, free: state.free - 1 }
         ] as const
       }
-      return [core.unit, state] as const
+      return [core.void, state] as const
     }))
   )
 
@@ -393,7 +393,7 @@ const forEach = <E, A, E2, R>(
   f: (a: A) => Effect.Effect<unknown, E2, R>
 ): Effect.Effect<unknown, E2, R> =>
   core.exitMatch(self.result, {
-    onFailure: () => core.unit,
+    onFailure: () => core.void,
     onSuccess: f
   })
 

package/src/internal/pubsub.ts

@@ -885,7 +885,7 @@ class SubscriptionImpl<in out A> implements Queue.Dequeue<A> {
             this.strategy.unsafeOnPubSubEmptySpace(this.pubsub, this.subscribers)
           })),
           core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)),
-          core.asUnit
+          core.asVoid
         )
       })
     )
@@ -1053,7 +1053,7 @@ class PubSubImpl<in out A> implements PubSub.PubSub<A> {
         this.scope.close(core.exitInterrupt(state.id())),
         core.zipRight(this.strategy.shutdown),
         core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)),
-        core.asUnit
+        core.asVoid
       )
     }))
   }
@@ -1298,8 +1298,8 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
             publishers,
             ([_, deferred, last]) =>
               last ?
-                pipe(core.deferredInterruptWith(deferred, fiberId), core.asUnit) :
-                core.unit,
+                pipe(core.deferredInterruptWith(deferred, fiberId), core.asVoid) :
+                core.void,
             false,
             false
           )
@@ -1408,7 +1408,7 @@ class BackPressureStrategy<in out A> implements PubSubStrategy<A> {
  */
 export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   handleSurplus(
@@ -1452,7 +1452,7 @@ export class DroppingStrategy<in out A> implements PubSubStrategy<A> {
  */
 export class SlidingStrategy<in out A> implements PubSubStrategy<A> {
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   handleSurplus(

package/src/internal/query.ts

@@ -12,7 +12,7 @@ import * as core from "./core.js"
 import { ensuring } from "./fiberRuntime.js"
 import { Listeners } from "./request.js"
 
-type RequestCache = Cache.Cache<Request.Request<any, any>, never, {
+type RequestCache = Cache.Cache<Request.Request<any, any>, {
   listeners: Request.Listeners
   handle: Deferred<any, any>
 }>
@@ -21,7 +21,7 @@ type RequestCache = Cache.Cache<Request.Request<any, any>, never, {
 export const currentCache = globalValue(
   Symbol.for("effect/FiberRef/currentCache"),
   () =>
-    core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, never, {
+    core.fiberRefUnsafeMake<RequestCache>(unsafeMakeWith<Request.Request<any, any>, {
       listeners: Request.Listeners
       handle: Deferred<any, any>
     }>(
@@ -153,7 +153,7 @@ export const cacheRequest = <A extends Request.Request<any, any>>(
         core.flatMap(cache.getEither(request), (orNew) => {
           switch (orNew._tag) {
             case "Left": {
-              return core.unit
+              return core.void
             }
             case "Right": {
               return core.deferredComplete(orNew.right.handle, result)
@@ -161,7 +161,7 @@ export const cacheRequest = <A extends Request.Request<any, any>>(
           }
         }))
     }
-    return core.unit
+    return core.void
   })
 }
 

package/src/internal/queue.ts

@@ -1,3 +1,4 @@
+import * as Array from "../Array.js"
 import * as Chunk from "../Chunk.js"
 import type * as Deferred from "../Deferred.js"
 import type * as Effect from "../Effect.js"
@@ -8,7 +9,6 @@ import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import { hasProperty } from "../Predicate.js"
 import type * as Queue from "../Queue.js"
-import * as ReadonlyArray from "../ReadonlyArray.js"
 import * as core from "./core.js"
 import * as fiberRuntime from "./fiberRuntime.js"
 
@@ -125,7 +125,7 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
           ),
           core.zipRight(this.strategy.shutdown),
           core.whenEffect(core.deferredSucceed(this.shutdownHook, void 0)),
-          core.asUnit
+          core.asVoid
         )
       })
     )
@@ -208,11 +208,11 @@ class QueueImpl<in out A> implements Queue.Queue<A> {
       if (MutableRef.get(this.shutdownFlag)) {
         return core.interrupt
       }
-      const values = ReadonlyArray.fromIterable(iterable)
+      const values = Array.fromIterable(iterable)
       const pTakers = this.queue.length() === 0
-        ? ReadonlyArray.fromIterable(unsafePollN(this.takers, values.length))
-        : ReadonlyArray.empty
-      const [forTakers, remaining] = pipe(values, ReadonlyArray.splitAt(pTakers.length))
+        ? Array.fromIterable(unsafePollN(this.takers, values.length))
+        : Array.empty
+      const [forTakers, remaining] = pipe(values, Array.splitAt(pTakers.length))
       for (let i = 0; i < pTakers.length; i++) {
         const taker = (pTakers as any)[i]
         const item = forTakers[i]
@@ -548,9 +548,9 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
                 isLastItem ?
                   pipe(
                     core.deferredInterruptWith(deferred, fiberId),
-                    core.asUnit
+                    core.asVoid
                   ) :
-                  core.unit,
+                  core.void,
               false,
               false
             )
@@ -602,7 +602,7 @@ class BackPressureStrategy<in out A> implements Queue.Strategy<A> {
   }
 
   unsafeOffer(iterable: Iterable<A>, deferred: Deferred.Deferred<boolean>): void {
-    const stuff = Array.from(iterable)
+    const stuff = Array.fromIterable(iterable)
     for (let i = 0; i < stuff.length; i++) {
       const value = stuff[i]
       if (i === stuff.length - 1) {
@@ -630,7 +630,7 @@ class DroppingStrategy<in out A> implements Queue.Strategy<A> {
   }
 
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   onCompleteTakersWithEmptyQueue(): void {
@@ -662,7 +662,7 @@ class SlidingStrategy<in out A> implements Queue.Strategy<A> {
   }
 
   get shutdown(): Effect.Effect<void> {
-    return core.unit
+    return core.void
   }
 
   onCompleteTakersWithEmptyQueue(): void {

package/src/internal/rateLimiter.ts

@@ -38,7 +38,7 @@ const tokenBucket = (limit: number, window: DurationInput): Effect.Effect<
     const refill: Effect.Effect<void> = Effect.sleep(millisPerToken).pipe(
       Effect.zipRight(latch.releaseAll),
       Effect.zipRight(semaphore.release(1)),
-      Effect.flatMap((free) => free === limit ? Effect.unit : refill)
+      Effect.flatMap((free) => free === limit ? Effect.void : refill)
     )
     yield* _(
       latch.take(1),

package/src/internal/redBlackTree/iterator.ts

@@ -1,5 +1,5 @@
+import * as Array from "../../Array.js"
 import * as Option from "../../Option.js"
-import * as ReadonlyArray from "../../ReadonlyArray.js"
 import type * as RBT from "../../RedBlackTree.js"
 import type { RedBlackTreeImpl } from "../redBlackTree.js"
 import type * as Node from "./node.js"
@@ -83,7 +83,7 @@ export class RedBlackTreeIterator<in out K, out V> implements Iterator<[K, V]> {
    * Returns the key
    */
   get entry(): Option.Option<[K, V]> {
-    return Option.map(ReadonlyArray.last(this.stack), (node) => [node.key, node.value])
+    return Option.map(Array.last(this.stack), (node) => [node.key, node.value])
   }
 
   /**

package/src/internal/reloadable.ts

@@ -139,5 +139,5 @@ export const reloadFork = <T extends Context.Tag<any, any>>(
       reloadable.reload,
       effect.ignoreLogged,
       fiberRuntime.forkDaemon,
-      core.asUnit
+      core.asVoid
     ))

package/src/internal/runtime.ts

@@ -1,4 +1,5 @@
 import { equals } from "effect/Equal"
+import type * as ReadonlyArray from "../Array.js"
 import type * as Cause from "../Cause.js"
 import * as Context from "../Context.js"
 import type * as Effect from "../Effect.js"
@@ -12,7 +13,6 @@ import * as Inspectable from "../Inspectable.js"
 import * as Option from "../Option.js"
 import { pipeArguments } from "../Pipeable.js"
 import * as Predicate from "../Predicate.js"
-import type * as ReadonlyArray from "../ReadonlyArray.js"
 import type * as Runtime from "../Runtime.js"
 import type * as RuntimeFlags from "../RuntimeFlags.js"
 import * as _scheduler from "../Scheduler.js"
@@ -66,7 +66,7 @@ export const unsafeFork = <R>(runtime: Runtime.Runtime<R>) =>
           core.scopeAddFinalizer(
             closeableScope,
             core.fiberIdWith((id) =>
-              equals(id, fiberRuntime.id()) ? core.unit : core.interruptAsFiber(fiberRuntime, id)
+              equals(id, fiberRuntime.id()) ? core.void : core.interruptAsFiber(fiberRuntime, id)
             )
           ),
           core.onExit(self, (exit) => _scope.close(closeableScope, exit))
@@ -135,7 +135,7 @@ class AsyncFiberExceptionImpl<A, E = never> extends Error implements Runtime.Asy
   readonly _tag = "AsyncFiberException"
   constructor(readonly fiber: Fiber.RuntimeFiber<A, E>) {
     super(
-      `Fiber #${fiber.id().id} cannot be be resolved synchronously, this is caused by using runSync on an effect that performs async work`
+      `Fiber #${fiber.id().id} cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work`
     )
     this.name = this._tag
     this.stack = this.message
@@ -483,12 +483,12 @@ export const asyncEffect = <A, E, R, R3, E2, R2>(
                     onFailure: (cause) => core.deferredFailCause(deferred, cause),
                     onSuccess: (cleanup_) => {
                       cleanup = cleanup_
-                      return core.unit
+                      return core.void
                     }
                   }
                 )
               )),
-              restore(core.onInterrupt(core.deferredAwait(deferred), () => cleanup ?? core.unit))
+              restore(core.onInterrupt(core.deferredAwait(deferred), () => cleanup ?? core.void))
             )
           ))
     )

package/src/internal/schedule.ts

@@ -18,7 +18,6 @@ import type * as Schedule from "../Schedule.js"
 import * as ScheduleDecision from "../ScheduleDecision.js"
 import * as Interval from "../ScheduleInterval.js"
 import * as Intervals from "../ScheduleIntervals.js"
-import type * as Types from "../Types.js"
 import * as internalCause from "./cause.js"
 import * as effect from "./core-effect.js"
 import * as core from "./core.js"
@@ -247,7 +246,7 @@ export const as = dual<
 >(2, (self, out) => map(self, () => out))
 
 /** @internal */
-export const asUnit = <Out, In, R>(
+export const asVoid = <Out, In, R>(
   self: Schedule.Schedule<Out, In, R>
 ): Schedule.Schedule<void, In, R> => map(self, constVoid)
 
@@ -1903,7 +1902,7 @@ export const retry_combined: {
     self: Effect.Effect<A, E, R>
   ) => Effect.Retry.Return<R, E, A, O>
   <B, E, R1>(
-    policy: Schedule.Schedule<B, Types.NoInfer<E>, R1>
+    policy: Schedule.Schedule<B, NoInfer<E>, R1>
   ): <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R1 | R>
   <A, E, R, O extends Effect.Retry.Options<E>>(
     self: Effect.Effect<A, E, R>,
@@ -1949,13 +1948,13 @@ export const retry_combined: {
 /** @internal */
 export const retryOrElse_Effect = dual<
   <A1, E, R1, A2, E2, R2>(
-    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
-    orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
+    orElse: (e: NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => <A, R>(self: Effect.Effect<A, E, R>) => Effect.Effect<A | A2, E2, R | R1 | R2>,
   <A, E, R, A1, R1, A2, E2, R2>(
     self: Effect.Effect<A, E, R>,
-    policy: Schedule.Schedule<A1, Types.NoInfer<E>, R1>,
-    orElse: (e: Types.NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
+    policy: Schedule.Schedule<A1, NoInfer<E>, R1>,
+    orElse: (e: NoInfer<E>, out: A1) => Effect.Effect<A2, E2, R2>
   ) => Effect.Effect<A | A2, E2, R | R1 | R2>
 >(3, (self, policy, orElse) =>
   core.flatMap(
@@ -2060,7 +2059,7 @@ export const elapsed: Schedule.Schedule<Duration.Duration> = makeWithState(
 export const forever: Schedule.Schedule<number> = unfold(0, (n) => n + 1)
 
 /** @internal */
-export const once: Schedule.Schedule<void> = asUnit(recurs(1))
+export const once: Schedule.Schedule<void> = asVoid(recurs(1))
 
 /** @internal */
-export const stop: Schedule.Schedule<void> = asUnit(recurs(0))
+export const stop: Schedule.Schedule<void> = asVoid(recurs(0))