effect 4.0.0-beta.5 → 4.0.0-beta.51

package/src/Pipeable.ts

@@ -554,8 +554,39 @@ export const pipeArguments = <A>(self: A, args: IArguments): unknown => {
 /**
  * @since 4.0.0
  */
-export const Class: new() => Pipeable = class {
+export const Prototype: Pipeable = {
   pipe() {
     return pipeArguments(this, arguments)
   }
 }
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const Class: new() => Pipeable = (function() {
+  function PipeableBase() {}
+  PipeableBase.prototype = Prototype
+  return PipeableBase as any
+})()
+
+/**
+ * @since 4.0.0
+ * @category models
+ */
+export interface PipeableConstructor {
+  new(...args: ReadonlyArray<any>): Pipeable
+}
+
+/**
+ * @since 4.0.0
+ * @category constructors
+ */
+export const Mixin = <TBase extends new(...args: ReadonlyArray<any>) => any>(
+  klass: TBase
+): TBase & PipeableConstructor =>
+  (class extends klass {
+    pipe() {
+      return pipeArguments(this, arguments)
+    }
+  })

package/src/Pool.ts

@@ -3,18 +3,20 @@
  */
 import type * as Cause from "./Cause.ts"
 import { Clock } from "./Clock.ts"
+import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import type * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
 import { dual, identity } from "./Function.ts"
 import * as Iterable from "./Iterable.ts"
+import * as Latch from "./Latch.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Queue from "./Queue.ts"
 import { UnhandledLogLevel } from "./References.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
+import * as Semaphore from "./Semaphore.ts"
 
 const TypeId = "~effect/Pool"
 
@@ -52,11 +54,11 @@ export interface Config<A, E> {
 export interface State<A, E> {
   readonly scope: Scope.Scope
   isShuttingDown: boolean
-  readonly semaphore: Effect.Semaphore
-  readonly resizeSemaphore: Effect.Semaphore
+  readonly semaphore: Semaphore.Semaphore
+  readonly resizeSemaphore: Semaphore.Semaphore
   readonly items: Set<PoolItem<A, E>>
   readonly available: Set<PoolItem<A, E>>
-  readonly availableLatch: Effect.Latch
+  readonly availableLatch: Latch.Latch
   readonly invalidated: Set<PoolItem<A, E>>
   waiters: number
 }
@@ -170,7 +172,7 @@ export const makeWithTTL = <A, E, R>(options: {
   readonly max: number
   readonly concurrency?: number | undefined
   readonly targetUtilization?: number | undefined
-  readonly timeToLive: Duration.DurationInput
+  readonly timeToLive: Duration.Input
   readonly timeToLiveStrategy?: "creation" | "usage" | undefined
 }): Effect.Effect<Pool<A, E>, never, R | Scope.Scope> =>
   Effect.flatMap(
@@ -193,11 +195,11 @@ export const makeWithStrategy = <A, E, R>(options: {
   readonly strategy: Strategy<A, E>
 }): Effect.Effect<Pool<A, E>, never, Scope.Scope | R> =>
   Effect.uninterruptibleMask(Effect.fnUntraced(function*(restore) {
-    const services = yield* Effect.services<R | Scope.Scope>()
-    const scope = ServiceMap.get(services, Scope.Scope)
-    const acquire = Effect.updateServices(
+    const services = yield* Effect.context<R | Scope.Scope>()
+    const scope = Context.get(services, Scope.Scope)
+    const acquire = Effect.updateContext(
       options.acquire,
-      (input) => ServiceMap.merge(services, input)
+      (input) => Context.merge(services, input)
     ) as Effect.Effect<A, E, Scope.Scope>
     const concurrency = options.concurrency ?? 1
 
@@ -212,11 +214,11 @@ export const makeWithStrategy = <A, E, R>(options: {
     const state: State<A, E> = {
       scope,
       isShuttingDown: false,
-      semaphore: Effect.makeSemaphoreUnsafe(concurrency * options.max),
-      resizeSemaphore: Effect.makeSemaphoreUnsafe(1),
+      semaphore: Semaphore.makeUnsafe(concurrency * options.max),
+      resizeSemaphore: Semaphore.makeUnsafe(1),
       items: new Set(),
       available: new Set(),
-      availableLatch: Effect.makeLatchUnsafe(false),
+      availableLatch: Latch.makeUnsafe(false),
       invalidated: new Set(),
       waiters: 0
     }
@@ -244,7 +246,7 @@ const shutdown = Effect.fnUntraced(function*<A, E>(self: Pool<A, E>) {
   if (self.state.isShuttingDown) return
   self.state.isShuttingDown = true
   const size = self.state.items.size
-  const semaphore = Effect.makeSemaphoreUnsafe(size)
+  const semaphore = Semaphore.makeUnsafe(size)
   for (const item of self.state.items) {
     if (item.refCount > 0) {
       item.finalizer = Effect.tap(item.finalizer, semaphore.release(1))
@@ -471,10 +473,10 @@ const strategyNoop = <A, E>(): Strategy<A, E> => ({
   reclaim: (_) => Effect.undefined
 })
 
-const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const clock = yield* Clock
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
-  const ttlMillis = Duration.toMillis(Duration.fromDurationInputUnsafe(ttl))
+  const ttlMillis = Duration.toMillis(Duration.fromInputUnsafe(ttl))
   const creationTimes = new WeakMap<PoolItem<A, E>, number>()
   return identity<Strategy<A, E>>({
     run: (pool) => {
@@ -504,7 +506,7 @@ const strategyCreationTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Dura
   })
 })
 
-const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.DurationInput) {
+const strategyUsageTTL = Effect.fnUntraced(function*<A, E>(ttl: Duration.Input) {
   const queue = yield* Queue.unbounded<PoolItem<A, E>>()
   return identity<Strategy<A, E>>({
     run: (pool) => {

package/src/PubSub.ts

@@ -29,14 +29,17 @@
  * @since 2.0.0
  */
 import * as Arr from "./Array.ts"
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import type { LazyArg } from "./Function.ts"
 import { dual, identity } from "./Function.ts"
+import * as Latch from "./Latch.ts"
 import * as MutableList from "./MutableList.ts"
 import * as MutableRef from "./MutableRef.ts"
 import { nextPow2 } from "./Number.ts"
+import * as Option from "./Option.ts"
 import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import * as Scope from "./Scope.ts"
 import type { Covariant, Invariant } from "./Types.ts"
@@ -81,7 +84,7 @@ export interface PubSub<in out A> extends Pipeable {
   readonly pubsub: PubSub.Atomic<A>
   readonly subscribers: PubSub.Subscribers<A>
   readonly scope: Scope.Closeable
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<A>
 }
@@ -242,7 +245,7 @@ export interface Subscription<out A> extends Pipeable {
   readonly subscribers: PubSub.Subscribers<any>
   readonly subscription: PubSub.BackingSubscription<A>
   readonly pollers: MutableList.MutableList<Deferred.Deferred<any>>
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<any>
   readonly replayWindow: PubSub.ReplayWindow<A>
@@ -282,7 +285,7 @@ export const make = <A>(
       options.atomicPubSub(),
       new Map(),
       Scope.makeUnsafe(),
-      Effect.makeLatchUnsafe(false),
+      Latch.makeUnsafe(false),
       MutableRef.make(false),
       options.strategy()
     )
@@ -879,7 +882,7 @@ export const publish: {
 } = dual(2, <A>(self: PubSub<A>, value: A): Effect.Effect<boolean> =>
   Effect.suspend(() => {
     if (self.shutdownFlag.current) {
-      return Effect.interrupt
+      return Effect.succeed(false)
     }
 
     if (self.pubsub.publish(value)) {
@@ -1108,7 +1111,7 @@ export const publishAll: {
 } = dual(2, <A>(self: PubSub<A>, elements: Iterable<A>): Effect.Effect<boolean> =>
   Effect.suspend(() => {
     if (self.shutdownFlag.current) {
-      return Effect.interrupt
+      return Effect.succeed(false)
     }
     const surplus = self.pubsub.publishAll(elements)
     self.strategy.completeSubscribersUnsafe(self.pubsub, self.subscribers)
@@ -1171,9 +1174,16 @@ export const publishAll: {
  * @category subscription
  */
 export const subscribe = <A>(self: PubSub<A>): Effect.Effect<Subscription<A>, never, Scope.Scope> =>
-  Effect.acquireRelease(
-    Effect.sync(() => makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy)),
-    unsubscribe
+  Effect.uninterruptible(
+    Effect.contextWith((services) => {
+      const localScope = Context.get(services, Scope.Scope)
+      const scope = Scope.forkUnsafe(self.scope)
+      const subscription = makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy)
+      return Scope.addFinalizer(scope, unsubscribe(subscription)).pipe(
+        Effect.andThen(Scope.addFinalizerExit(localScope, (exit) => Scope.close(scope, exit))),
+        Effect.as(subscription)
+      )
+    })
   )
 
 const unsubscribe = <A>(self: Subscription<A>): Effect.Effect<void> =>
@@ -1635,14 +1645,14 @@ export const remaining = <A>(self: Subscription<A>): Effect.Effect<number> =>
  *
  * // Unsafe synchronous check for remaining messages
  * const remainingOption = PubSub.remainingUnsafe(subscription)
- * if (remainingOption) {
- *   console.log("Messages available:", remainingOption)
+ * if (remainingOption._tag === "Some") {
+ *   console.log("Messages available:", remainingOption.value)
  * } else {
  *   console.log("Subscription is shutdown")
  * }
  *
  * // Useful for polling or batching scenarios
- * if (remainingOption && remainingOption > 10) {
+ * if (remainingOption._tag === "Some" && remainingOption.value > 10) {
  *   // Process messages in batch
  * }
  * ```
@@ -1650,11 +1660,11 @@ export const remaining = <A>(self: Subscription<A>): Effect.Effect<number> =>
  * @since 4.0.0
  * @category getters
  */
-export const remainingUnsafe = <A>(self: Subscription<A>): number | undefined => {
+export const remainingUnsafe = <A>(self: Subscription<A>): Option.Option<number> => {
   if (self.shutdownFlag.current) {
-    return undefined
+    return Option.none()
   }
-  return self.subscription.size() + self.replayWindow.remaining
+  return Option.some(self.subscription.size() + self.replayWindow.remaining)
 }
 
 // -----------------------------------------------------------------------------
@@ -1701,7 +1711,7 @@ const makeSubscriptionUnsafe = <A>(
     subscribers,
     pubsub.subscribe(),
     MutableList.make<Deferred.Deferred<A>>(),
-    Effect.makeLatchUnsafe(false),
+    Latch.makeUnsafe(false),
     MutableRef.make(false),
     strategy,
     pubsub.replayWindow()
@@ -2446,7 +2456,7 @@ class SubscriptionImpl<in out A> implements Subscription<A> {
   readonly subscribers: PubSub.Subscribers<A>
   readonly subscription: PubSub.BackingSubscription<A>
   readonly pollers: MutableList.MutableList<Deferred.Deferred<A>>
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<A>
   readonly replayWindow: PubSub.ReplayWindow<A>
@@ -2456,7 +2466,7 @@ class SubscriptionImpl<in out A> implements Subscription<A> {
     subscribers: PubSub.Subscribers<A>,
     subscription: PubSub.BackingSubscription<A>,
     pollers: MutableList.MutableList<Deferred.Deferred<A>>,
-    shutdownHook: Effect.Latch,
+    shutdownHook: Latch.Latch,
     shutdownFlag: MutableRef.MutableRef<boolean>,
     strategy: PubSub.Strategy<A>,
     replayWindow: PubSub.ReplayWindow<A>
@@ -2484,7 +2494,7 @@ class PubSubImpl<in out A> implements PubSub<A> {
   readonly pubsub: PubSub.Atomic<A>
   readonly subscribers: PubSub.Subscribers<A>
   readonly scope: Scope.Closeable
-  readonly shutdownHook: Effect.Latch
+  readonly shutdownHook: Latch.Latch
   readonly shutdownFlag: MutableRef.MutableRef<boolean>
   readonly strategy: PubSub.Strategy<A>
 
@@ -2492,7 +2502,7 @@ class PubSubImpl<in out A> implements PubSub<A> {
     pubsub: PubSub.Atomic<A>,
     subscribers: PubSub.Subscribers<A>,
     scope: Scope.Closeable,
-    shutdownHook: Effect.Latch,
+    shutdownHook: Latch.Latch,
     shutdownFlag: MutableRef.MutableRef<boolean>,
     strategy: PubSub.Strategy<A>
   ) {
@@ -2513,7 +2523,7 @@ const makePubSubUnsafe = <A>(
   pubsub: PubSub.Atomic<A>,
   subscribers: PubSub.Subscribers<A>,
   scope: Scope.Closeable,
-  shutdownHook: Effect.Latch,
+  shutdownHook: Latch.Latch,
   shutdownFlag: MutableRef.MutableRef<boolean>,
   strategy: PubSub.Strategy<A>
 ): PubSub<A> => new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy)

package/src/Pull.ts

@@ -95,7 +95,7 @@ export const catchDone: {
   effect: Effect<A, E, R>,
   f: (leftover: Cause.Done.Extract<E>) => Effect<A2, E2, R2>
 ): Effect<A | A2, ExcludeDone<E> | E2, R | R2> =>
-  internalEffect.catchCauseIf(effect, filterDoneLeftover as any, (l: any) => f(l)) as any)
+  internalEffect.catchCauseFilter(effect, filterDoneLeftover as any, (l: any) => f(l)) as any)
 
 /**
  * Checks if a Cause contains any done errors.

package/src/Queue.ts

@@ -14,7 +14,7 @@ import * as MutableList from "./MutableList.ts"
 import * as Option from "./Option.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Pull from "./Pull.ts"
-import type { Scheduler } from "./Scheduler.ts"
+import type { SchedulerDispatcher } from "./Scheduler.ts"
 import type * as Types from "./Types.ts"
 
 const TypeId = "~effect/Queue"
@@ -96,7 +96,7 @@ export const asDequeue: <A, E>(self: Queue<A, E>) => Dequeue<A, E> = identity
 export interface Enqueue<in A, in E = never> extends Inspectable {
   readonly [EnqueueTypeId]: Enqueue.Variance<A, E>
   readonly strategy: "suspend" | "dropping" | "sliding"
-  readonly scheduler: Scheduler
+  readonly dispatcher: SchedulerDispatcher
   capacity: number
   messages: MutableList.MutableList<any>
   state: Queue.State<any, any>
@@ -151,7 +151,7 @@ export declare namespace Enqueue {
 export interface Dequeue<out A, out E = never> extends Inspectable {
   readonly [DequeueTypeId]: Dequeue.Variance<A, E>
   readonly strategy: "suspend" | "dropping" | "sliding"
-  readonly scheduler: Scheduler
+  readonly dispatcher: SchedulerDispatcher
   capacity: number
   messages: MutableList.MutableList<any>
   state: Queue.State<any, any>
@@ -341,7 +341,7 @@ export const make = <A, E = never>(
 ): Effect<Queue<A, E>> =>
   core.withFiber((fiber) => {
     const self = Object.create(QueueProto)
-    self.scheduler = fiber.currentScheduler
+    self.dispatcher = fiber.currentDispatcher
     self.capacity = options?.capacity ?? Number.POSITIVE_INFINITY
     self.strategy = options?.strategy ?? "suspend"
     self.messages = MutableList.make()
@@ -710,7 +710,7 @@ export const offerAllUnsafe = <A, E>(self: Enqueue<A, E>, messages: Iterable<A>)
  * @category Completion
  * @since 4.0.0
  */
-export const fail = <A, E>(self: Queue<A, E>, error: E) => failCause(self, core.causeFail(error))
+export const fail = <A, E>(self: Enqueue<A, E>, error: E) => failCause(self, core.causeFail(error))
 
 /**
  * Fail the queue with a cause. If the queue is already done, `false` is
@@ -1113,7 +1113,6 @@ export const collect = <A, E>(self: Dequeue<A, E | Done>): Effect<Array<A>, Pull
           while: constTrue,
           body: constant(takeAll(self)),
           step(items: Arr.NonEmptyArray<A>) {
-            out.push(...items)
             for (let i = 0; i < items.length; i++) {
               out.push(items[i])
             }
@@ -1137,7 +1136,7 @@ export const collect = <A, E>(self: Dequeue<A, E | Done>): Effect<Array<A>, Pull
  * import { Cause, Effect, Queue } from "effect"
  *
  * const program = Effect.gen(function*() {
- *   const queue = yield* Queue.bounded<number>(10)
+ *   const queue = yield* Queue.bounded<number, Cause.Done>(10)
  *
  *   // Add several messages
  *   yield* Queue.offerAll(queue, [1, 2, 3, 4, 5, 6, 7])
@@ -1150,7 +1149,10 @@ export const collect = <A, E>(self: Dequeue<A, E | Done>): Effect<Array<A>, Pull
  *   const next2 = yield* Queue.takeN(queue, 2)
  *   console.log(next2) // [4, 5]
  *
- *   // Take remaining messages (will take 2, even though we asked for 5)
+ *   // End the queue before taking; now it can return fewer than requested
+ *   yield* Queue.end(queue)
+ *
+ *   // Take remaining messages (takes 2, even though we asked for 5)
  *   const remaining = yield* Queue.takeN(queue, 5)
  *   console.log(remaining) // [6, 7]
  * })
@@ -1677,7 +1679,7 @@ const scheduleReleaseTaker = <A, E>(self: Enqueue<A, E>) => {
     return
   }
   self.scheduleRunning = true
-  self.scheduler.scheduleTask(() => releaseTakers(self), 0)
+  self.dispatcher.scheduleTask(() => releaseTakers(self), 0)
 }
 
 const takeBetweenUnsafe = <A, E>(

package/src/Random.ts

@@ -21,10 +21,11 @@
  *
  * @since 4.0.0
  */
+import type * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import { dual } from "./Function.ts"
+import * as random from "./internal/random.ts"
 import * as Predicate from "./Predicate.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * Represents a service for generating random numbers.
@@ -49,23 +50,13 @@ import * as ServiceMap from "./ServiceMap.ts"
  * @since 4.0.0
  * @category Random Number Generators
  */
-export const Random = ServiceMap.Reference<{
+export const Random: Context.Reference<{
   nextIntUnsafe(): number
   nextDoubleUnsafe(): number
-}>("effect/Random", {
-  defaultValue: () => ({
-    nextIntUnsafe() {
-      return Math.floor(Math.random() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) +
-        Number.MIN_SAFE_INTEGER
-    },
-    nextDoubleUnsafe() {
-      return Math.random()
-    }
-  })
-})
+}> = random.Random
 
 const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effect<A> =>
-  Effect.withFiber((fiber) => Effect.succeed(f(ServiceMap.get(fiber.services, Random))))
+  Effect.withFiber((fiber) => Effect.succeed(f(fiber.getRef(Random))))
 
 /**
  * Generates a random number between 0 (inclusive) and 1 (inclusive).
@@ -85,6 +76,24 @@ const randomWith = <A>(f: (random: typeof Random["Service"]) => A): Effect.Effec
  */
 export const next: Effect.Effect<number> = randomWith((r) => r.nextDoubleUnsafe())
 
+/**
+ * Generates a random boolean value.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const value = yield* Random.nextBoolean
+ *   console.log("Random boolean:", value)
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Random Number Generators
+ */
+export const nextBoolean: Effect.Effect<boolean> = randomWith((r) => r.nextDoubleUnsafe() > 0.5)
+
 /**
  * Generates a random integer between `Number.MIN_SAFE_INTEGER` (inclusive)
  * and `Number.MAX_SAFE_INTEGER` (inclusive).
@@ -156,6 +165,34 @@ export const nextIntBetween = (min: number, max: number, options?: {
   })
 }
 
+/**
+ * Uses the pseudo-random number generator to shuffle the specified iterable.
+ *
+ * @example
+ * ```ts
+ * import { Effect, Random } from "effect"
+ *
+ * const program = Effect.gen(function*() {
+ *   const values = yield* Random.shuffle([1, 2, 3, 4, 5])
+ *   console.log(values)
+ * })
+ * ```
+ *
+ * @since 4.0.0
+ * @category Random Number Generators
+ */
+export const shuffle = <A>(elements: Iterable<A>): Effect.Effect<Array<A>> =>
+  randomWith((r) => {
+    const buffer = Array.from(elements)
+    for (let i = buffer.length - 1; i >= 1; i = i - 1) {
+      const index = Math.min(i, Math.floor(r.nextDoubleUnsafe() * (i + 1)))
+      const value = buffer[i]!
+      buffer[i] = buffer[index]!
+      buffer[index] = value
+    }
+    return buffer
+  })
+
 /**
  * Generates a random UUID (v4) string.
  *

package/src/RcMap.ts

@@ -3,6 +3,7 @@
  */
 import * as Cause from "./Cause.ts"
 import { Clock } from "./Clock.ts"
+import * as Context from "./Context.ts"
 import * as Deferred from "./Deferred.ts"
 import * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
@@ -13,7 +14,6 @@ import * as MutableHashMap from "./MutableHashMap.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/RcMap"
 
@@ -53,7 +53,7 @@ const TypeId = "~effect/RcMap"
 export interface RcMap<in out K, in out A, in out E = never> extends Pipeable {
   readonly [TypeId]: typeof TypeId
   readonly lookup: (key: K) => Effect.Effect<A, E, Scope.Scope>
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
   readonly scope: Scope.Scope
   readonly idleTimeToLive: (key: K) => Duration.Duration
   readonly capacity: number
@@ -196,14 +196,14 @@ export declare namespace State {
 
 const makeUnsafe = <K, A, E>(options: {
   readonly lookup: (key: K) => Effect.Effect<A, E, Scope.Scope>
-  readonly services: ServiceMap.ServiceMap<never>
+  readonly context: Context.Context<never>
   readonly scope: Scope.Scope
   readonly idleTimeToLive: (key: K) => Duration.Duration
   readonly capacity: number
 }): RcMap<K, A, E> => ({
   [TypeId]: TypeId,
   lookup: options.lookup,
-  services: options.services,
+  context: options.context,
   scope: options.scope,
   idleTimeToLive: options.idleTimeToLive,
   capacity: options.capacity,
@@ -292,7 +292,7 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity?: undefined
     }
   ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
@@ -335,25 +335,25 @@ export const make: {
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
-      readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+      readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
       readonly capacity: number
     }
   ): Effect.Effect<RcMap<K, A, E | Cause.ExceededCapacityError>, never, Scope.Scope | R>
 } = <K, A, E, R>(options: {
   readonly lookup: (key: K) => Effect.Effect<A, E, R>
-  readonly idleTimeToLive?: Duration.DurationInput | ((key: K) => Duration.DurationInput) | undefined
+  readonly idleTimeToLive?: Duration.Input | ((key: K) => Duration.Input) | undefined
   readonly capacity?: number | undefined
 }) =>
   Effect.withFiber<RcMap<K, A, E>, never, R | Scope.Scope>((fiber) => {
-    const services = fiber.services as ServiceMap.ServiceMap<R | Scope.Scope>
-    const scope = ServiceMap.get(services, Scope.Scope)
+    const context = fiber.context as Context.Context<R | Scope.Scope>
+    const scope = Context.get(context, Scope.Scope)
     const self = makeUnsafe<K, A, E>({
       lookup: options.lookup as any,
-      services,
+      context,
       scope,
       idleTimeToLive: typeof options.idleTimeToLive === "function"
-        ? flow(options.idleTimeToLive, Duration.fromDurationInputUnsafe)
-        : constant(Duration.fromDurationInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
+        ? flow(options.idleTimeToLive, Duration.fromInputUnsafe)
+        : constant(Duration.fromInputUnsafe(options.idleTimeToLive ?? Duration.zero)),
       capacity: Math.max(options.capacity ?? Number.POSITIVE_INFINITY, 0)
     })
     return Effect.as(
@@ -489,17 +489,17 @@ export const get: {
         }
         ;(entry as any).finalizer = release(self, key, entry)
         MutableHashMap.set(state.map, key, entry)
-        const services = new Map(self.services.mapUnsafe)
-        parent.services.mapUnsafe.forEach((value, key) => {
-          services.set(key, value)
+        const context = new Map(self.context.mapUnsafe)
+        parent.context.mapUnsafe.forEach((value, key) => {
+          context.set(key, value)
         })
-        services.set(Scope.Scope.key, entry.scope)
+        context.set(Scope.Scope.key, entry.scope)
         self.lookup(key).pipe(
-          Effect.runForkWith(ServiceMap.makeUnsafe(services)),
+          Effect.runForkWith(Context.makeUnsafe(context)),
           Fiber.runIn(entry.scope)
         ).addObserver((exit) => Deferred.doneUnsafe(entry.deferred, exit))
       }
-      const scope = ServiceMap.getUnsafe(parent.services, Scope.Scope)
+      const scope = Context.getUnsafe(parent.context, Scope.Scope)
       return Scope.addFinalizer(scope, entry.finalizer).pipe(
         Effect.andThen(restore(Deferred.await(entry.deferred)))
       )
@@ -541,7 +541,7 @@ const release = <K, A, E>(self: RcMap<K, A, E>, key: K, entry: State.Entry<A, E>
       Effect.ensuring(Effect.sync(() => {
         entry.fiber = undefined
       })),
-      Effect.runForkWith(fiber.services),
+      Effect.runForkWith(fiber.context),
       Fiber.runIn(self.scope)
     )
     return Effect.void

package/src/RcRef.ts

@@ -120,7 +120,7 @@ export const make: <A, E, R>(
      * When the reference count reaches zero, the resource will be released
      * after this duration.
      */
-    readonly idleTimeToLive?: Duration.DurationInput | undefined
+    readonly idleTimeToLive?: Duration.Input | undefined
   }
 ) => Effect.Effect<RcRef<A, E>, never, R | Scope> = internal.make