effect 4.0.0-beta.5 → 4.0.0-beta.50

package/src/ManagedRuntime.ts

@@ -1,13 +1,13 @@
 /**
  * @since 2.0.0
  */
+import type * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import * as Fiber from "./Fiber.ts"
 import * as Layer from "./Layer.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Scope from "./Scope.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 import type { Mutable } from "./Types.ts"
 
 const TypeId = "~effect/ManagedRuntime"
@@ -45,13 +45,13 @@ export declare namespace ManagedRuntime {
 export interface ManagedRuntime<in R, out ER> {
   readonly [TypeId]: typeof TypeId
   readonly memoMap: Layer.MemoMap
-  readonly servicesEffect: Effect.Effect<ServiceMap.ServiceMap<R>, ER>
-  readonly services: () => Promise<ServiceMap.ServiceMap<R>>
+  readonly contextEffect: Effect.Effect<Context.Context<R>, ER>
+  readonly context: () => Promise<Context.Context<R>>
 
   // internal
   readonly scope: Scope.Closeable
   // internal
-  cachedServices: ServiceMap.ServiceMap<R> | undefined
+  cachedContext: Context.Context<R> | undefined
 
   /**
    * Executes the effect using the provided Scheduler or using the global
@@ -135,13 +135,13 @@ export interface ManagedRuntime<in R, out ER> {
  * @category runtime class
  * @example
  * ```ts
- * import { Console, Effect, Layer, ManagedRuntime, ServiceMap } from "effect"
+ * import { Console, Effect, Layer, ManagedRuntime, Context } from "effect"
  *
- * class Notifications extends ServiceMap.Service<Notifications, {
+ * class Notifications extends Context.Service<Notifications, {
  *   readonly notify: (message: string) => Effect.Effect<void>
  * }>()("Notifications") {
- *   static layer = Layer.succeed(this)({
- *     notify: (message) => Console.log(message)
+ *   static readonly layer = Layer.succeed(this)({
+ *     notify: Effect.fn("Notifications.notify")((message) => Console.log(message))
  *   })
  * }
  *
@@ -164,22 +164,35 @@ export const make = <R, ER>(
   } | undefined
 ): ManagedRuntime<R, ER> => {
   const memoMap = options?.memoMap ?? Layer.makeMemoMapUnsafe()
-  const scope = Scope.makeUnsafe()
-  let buildFiber: Fiber.Fiber<ServiceMap.ServiceMap<R>, ER> | undefined
-  const servicesEffect = Effect.withFiber<ServiceMap.ServiceMap<R>, ER>((fiber) => {
+  const scope = Scope.makeUnsafe("parallel")
+  const layerScope = Scope.forkUnsafe(scope, "sequential")
+  const defaultRunOptions: Effect.RunOptions = {
+    onFiberStart: Fiber.runIn(scope)
+  }
+  const mergeRunOptions = <O extends Effect.RunOptions>(options?: O): O =>
+    options
+      ? {
+        ...options,
+        onFiberStart: options.onFiberStart ?
+          (fiber) => {
+            defaultRunOptions.onFiberStart!(fiber)
+            options.onFiberStart!(fiber)
+          } :
+          defaultRunOptions.onFiberStart
+      }
+      : defaultRunOptions as O
+  let buildFiber: Fiber.Fiber<Context.Context<R>, ER> | undefined
+  const contextEffect = Effect.withFiber<Context.Context<R>, ER>((fiber) => {
     if (!buildFiber) {
-      buildFiber = Fiber.runIn(
-        Effect.runFork(
-          Effect.tap(
-            Layer.buildWithMemoMap(layer, memoMap, scope),
-            (services) =>
-              Effect.sync(() => {
-                self.cachedServices = services
-              })
-          ),
-          { scheduler: fiber.currentScheduler }
+      buildFiber = Effect.runFork(
+        Effect.tap(
+          Layer.buildWithMemoMap(layer, memoMap, layerScope),
+          (context) =>
+            Effect.sync(() => {
+              self.cachedContext = context
+            })
         ),
-        scope
+        { ...defaultRunOptions, scheduler: fiber.currentScheduler }
       )
     }
     return Effect.flatten(Fiber.await(buildFiber))
@@ -188,25 +201,25 @@ export const make = <R, ER>(
     [TypeId]: TypeId,
     memoMap,
     scope,
-    servicesEffect,
-    cachedServices: undefined,
-    services() {
-      return self.cachedServices === undefined ?
-        Effect.runPromise(self.servicesEffect) :
-        Promise.resolve(self.cachedServices)
+    contextEffect: contextEffect,
+    cachedContext: undefined,
+    context() {
+      return self.cachedContext === undefined ?
+        Effect.runPromise(self.contextEffect) :
+        Promise.resolve(self.cachedContext)
     },
     dispose(): Promise<void> {
       return Effect.runPromise(self.disposeEffect)
     },
     disposeEffect: Effect.suspend(() => {
-      ;(self as Mutable<ManagedRuntime<R, ER>>).servicesEffect = Effect.die("ManagedRuntime disposed")
-      self.cachedServices = undefined
+      ;(self as Mutable<ManagedRuntime<R, ER>>).contextEffect = Effect.die("ManagedRuntime disposed")
+      self.cachedContext = undefined
       return Scope.close(self.scope, Exit.void)
     }),
     runFork<A, E>(effect: Effect.Effect<A, E, R>, options?: Effect.RunOptions): Fiber.Fiber<A, E | ER> {
-      return self.cachedServices === undefined ?
-        Effect.runFork(provide(self, effect), options) :
-        Effect.runForkWith(self.cachedServices)(effect, options)
+      return self.cachedContext === undefined ?
+        Effect.runFork(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runForkWith(self.cachedContext)(effect, mergeRunOptions(options))
     },
     runCallback<A, E>(
       effect: Effect.Effect<A, E, R>,
@@ -214,31 +227,31 @@ export const make = <R, ER>(
         readonly onExit: (exit: Exit.Exit<A, E | ER>) => void
       }
     ): (interruptor?: number | undefined) => void {
-      return self.cachedServices === undefined ?
-        Effect.runCallback(provide(self, effect), options) :
-        Effect.runCallbackWith(self.cachedServices)(effect, options)
+      return self.cachedContext === undefined ?
+        Effect.runCallback(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runCallbackWith(self.cachedContext)(effect, mergeRunOptions(options))
     },
     runSyncExit<A, E>(effect: Effect.Effect<A, E, R>): Exit.Exit<A, E | ER> {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runSyncExit(provide(self, effect)) :
-        Effect.runSyncExitWith(self.cachedServices)(effect)
+        Effect.runSyncExitWith(self.cachedContext)(effect)
     },
     runSync<A, E>(effect: Effect.Effect<A, E, R>): A {
-      return self.cachedServices === undefined ?
+      return self.cachedContext === undefined ?
         Effect.runSync(provide(self, effect)) :
-        Effect.runSyncWith(self.cachedServices)(effect)
+        Effect.runSyncWith(self.cachedContext)(effect)
     },
     runPromiseExit<A, E>(effect: Effect.Effect<A, E, R>, options?: Effect.RunOptions): Promise<Exit.Exit<A, E | ER>> {
-      return self.cachedServices === undefined ?
-        Effect.runPromiseExit(provide(self, effect), options) :
-        Effect.runPromiseExitWith(self.cachedServices)(effect, options)
+      return self.cachedContext === undefined ?
+        Effect.runPromiseExit(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runPromiseExitWith(self.cachedContext)(effect, mergeRunOptions(options))
     },
     runPromise<A, E>(effect: Effect.Effect<A, E, R>, options?: {
       readonly signal?: AbortSignal | undefined
     }): Promise<A> {
-      return self.cachedServices === undefined ?
-        Effect.runPromise(provide(self, effect), options) :
-        Effect.runPromiseWith(self.cachedServices)(effect, options)
+      return self.cachedContext === undefined ?
+        Effect.runPromise(provide(self, effect), mergeRunOptions(options)) :
+        Effect.runPromiseWith(self.cachedContext)(effect, mergeRunOptions(options))
     }
   }
   return self
@@ -249,7 +262,7 @@ function provide<R, ER, A, E>(
   effect: Effect.Effect<A, E, R>
 ): Effect.Effect<A, E | ER> {
   return Effect.flatMap(
-    managed.servicesEffect,
-    (services) => Effect.provideServices(effect, services)
+    managed.contextEffect,
+    (context) => Effect.provideContext(effect, context)
   )
 }

package/src/Metric.ts

@@ -138,6 +138,7 @@
  */
 
 import * as Arr from "./Array.ts"
+import * as Context from "./Context.ts"
 import * as Duration from "./Duration.ts"
 import type { Effect } from "./Effect.ts"
 import type { Exit } from "./Exit.ts"
@@ -149,7 +150,6 @@ import * as Order from "./Order.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
 import * as Predicate from "./Predicate.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import * as _String from "./String.ts"
 import type { Contravariant, Covariant } from "./Types.ts"
 
@@ -235,9 +235,9 @@ export interface Metric<in Input, out State> extends Pipeable {
   readonly type: Metric.Type
   readonly description: string | undefined
   readonly attributes: Metric.AttributeSet | undefined
-  readonly valueUnsafe: (context: ServiceMap.ServiceMap<never>) => State
-  readonly updateUnsafe: (input: Input, context: ServiceMap.ServiceMap<never>) => void
-  readonly modifyUnsafe: (input: Input, context: ServiceMap.ServiceMap<never>) => void
+  readonly valueUnsafe: (context: Context.Context<never>) => State
+  readonly updateUnsafe: (input: Input, context: Context.Context<never>) => void
+  readonly modifyUnsafe: (input: Input, context: Context.Context<never>) => void
 }
 
 /**
@@ -1457,9 +1457,9 @@ export declare namespace Metric {
    * @category interfaces
    */
   export interface Hooks<in Input, out State> {
-    readonly get: (context: ServiceMap.ServiceMap<never>) => State
-    readonly update: (input: Input, context: ServiceMap.ServiceMap<never>) => void
-    readonly modify: (input: Input, context: ServiceMap.ServiceMap<never>) => void
+    readonly get: (context: Context.Context<never>) => State
+    readonly update: (input: Input, context: Context.Context<never>) => void
+    readonly modify: (input: Input, context: Context.Context<never>) => void
   }
 
   /**
@@ -1761,7 +1761,7 @@ export const CurrentMetricAttributesKey = "effect/Metric/CurrentMetricAttributes
  * @since 4.0.0
  * @category References
  */
-export const CurrentMetricAttributes = ServiceMap.Reference<Metric.AttributeSet>(CurrentMetricAttributesKey, {
+export const CurrentMetricAttributes = Context.Reference<Metric.AttributeSet>(CurrentMetricAttributesKey, {
   defaultValue: () => ({})
 })
 
@@ -1773,7 +1773,7 @@ const MetricRegistryKey = "~effect/observability/Metric/MetricRegistryKey"
  * @since 4.0.0
  * @category References
  */
-export const MetricRegistry = ServiceMap.Reference<Map<string, Metric.Metadata<any, any>>>(
+export const MetricRegistry = Context.Reference<Map<string, Metric.Metadata<any, any>>>(
   MetricRegistryKey,
   { defaultValue: () => new Map() }
 )
@@ -1805,22 +1805,22 @@ abstract class Metric$<in Input, out State> implements Metric<Input, State> {
     this.attributes = attributes
   }
 
-  valueUnsafe(context: ServiceMap.ServiceMap<never>): State {
+  valueUnsafe(context: Context.Context<never>): State {
     return this.hook(context).get(context)
   }
 
-  modifyUnsafe(input: Input, context: ServiceMap.ServiceMap<never>): void {
+  modifyUnsafe(input: Input, context: Context.Context<never>): void {
     return this.hook(context).modify(input, context)
   }
 
-  updateUnsafe(input: Input, context: ServiceMap.ServiceMap<never>): void {
+  updateUnsafe(input: Input, context: Context.Context<never>): void {
     return this.hook(context).update(input, context)
   }
 
   abstract createHooks(): Metric.Hooks<Input, State>
 
-  hook(context: ServiceMap.ServiceMap<never>): Metric.Hooks<Input, State> {
-    const extraAttributes = ServiceMap.get(context, CurrentMetricAttributes)
+  hook(context: Context.Context<never>): Metric.Hooks<Input, State> {
+    const extraAttributes = Context.get(context, CurrentMetricAttributes)
     if (Object.keys(extraAttributes).length === 0) {
       if (Predicate.isNotUndefined(this.#metadata)) {
         return this.#metadata.hooks
@@ -1839,11 +1839,11 @@ abstract class Metric$<in Input, out State> implements Metric<Input, State> {
   }
 
   getOrCreate(
-    context: ServiceMap.ServiceMap<never>,
+    context: Context.Context<never>,
     attributes: Metric.Attributes | undefined
   ): Metric.Metadata<Input, State> {
     const key = makeKey(this, attributes)
-    const registry = ServiceMap.get(context, MetricRegistry)
+    const registry = Context.get(context, MetricRegistry)
     if (registry.has(key)) {
       return registry.get(key)!
     }
@@ -2035,12 +2035,12 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
   constructor(id: string, options: {
     readonly description?: string | undefined
     readonly attributes?: Metric.Attributes | undefined
-    readonly maxAge: Duration.DurationInput
+    readonly maxAge: Duration.Input
     readonly maxSize: number
     readonly quantiles: ReadonlyArray<number>
   }) {
     super(id, options?.description, attributesToRecord(options?.attributes))
-    this.#maxAge = Math.max(Duration.toMillis(Duration.fromDurationInputUnsafe(options.maxAge)), 0)
+    this.#maxAge = Math.max(Duration.toMillis(Duration.fromInputUnsafe(options.maxAge)), 0)
     this.#maxSize = options.maxSize
     this.#quantiles = options.quantiles
   }
@@ -2107,8 +2107,8 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
       }
     }
 
-    const get = (context: ServiceMap.ServiceMap<never>) => {
-      const clock = ServiceMap.get(context, InternalEffect.ClockRef)
+    const get = (context: Context.Context<never>) => {
+      const clock = Context.get(context, InternalEffect.ClockRef)
       const quantiles = snapshot(clock.currentTimeMillisUnsafe())
       return { quantiles, count, min, max, sum }
     }
@@ -2122,15 +2122,15 @@ class SummaryMetric extends Metric$<readonly [value: number, timestamp: number],
 class MetricTransform<in Input, out State, in Input2> extends Metric$<Input2, State> {
   type: Metric.Type
   readonly metric: Metric<Input, State>
-  override readonly valueUnsafe: (context: ServiceMap.ServiceMap<never>) => State
-  override readonly updateUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void
-  override readonly modifyUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void
+  override readonly valueUnsafe: (context: Context.Context<never>) => State
+  override readonly updateUnsafe: (input: Input2, context: Context.Context<never>) => void
+  override readonly modifyUnsafe: (input: Input2, context: Context.Context<never>) => void
 
   constructor(
     metric: Metric<Input, State>,
-    valueUnsafe: (context: ServiceMap.ServiceMap<never>) => State,
-    updateUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void,
-    modifyUnsafe: (input: Input2, context: ServiceMap.ServiceMap<never>) => void
+    valueUnsafe: (context: Context.Context<never>) => State,
+    updateUnsafe: (input: Input2, context: Context.Context<never>) => void,
+    modifyUnsafe: (input: Input2, context: Context.Context<never>) => void
   ) {
     super(metric.id, metric.description, metric.attributes)
     this.metric = metric
@@ -2808,14 +2808,14 @@ export const histogram = (name: string, options: {
 export const summary = (name: string, options: {
   readonly description?: string | undefined
   readonly attributes?: Metric.Attributes | undefined
-  readonly maxAge: Duration.DurationInput
+  readonly maxAge: Duration.Input
   readonly maxSize: number
   readonly quantiles: ReadonlyArray<number>
 }): Summary<number> =>
   mapInput(summaryWithTimestamp(name, options), (input, context) =>
     [
       input,
-      ServiceMap.get(context, InternalEffect.ClockRef).currentTimeMillisUnsafe()
+      Context.get(context, InternalEffect.ClockRef).currentTimeMillisUnsafe()
     ] as [number, number])
 
 /**
@@ -2854,7 +2854,7 @@ export const summary = (name: string, options: {
 export const summaryWithTimestamp = (name: string, options: {
   readonly description?: string | undefined
   readonly attributes?: Metric.Attributes | undefined
-  readonly maxAge: Duration.DurationInput
+  readonly maxAge: Duration.Input
   readonly maxSize: number
   readonly quantiles: ReadonlyArray<number>
 }): Summary<[value: number, timestamp: number]> => new SummaryMetric(name, options)
@@ -2956,7 +2956,7 @@ export const value = <Input, State>(
   self: Metric<Input, State>
 ): Effect<State> =>
   InternalEffect.flatMap(
-    InternalEffect.services(),
+    InternalEffect.context(),
     (context) => InternalEffect.sync(() => self.valueUnsafe(context))
   )
 
@@ -3168,7 +3168,7 @@ export const modify: {
   <Input, State>(self: Metric<Input, State>, input: Input) => Effect<void>
 >(2, (self, input) =>
   InternalEffect.flatMap(
-    InternalEffect.services(),
+    InternalEffect.context(),
     (context) => InternalEffect.sync(() => self.modifyUnsafe(input, context))
   ))
 
@@ -3426,7 +3426,7 @@ export const update: {
 >(
   2,
   (self, input) =>
-    InternalEffect.servicesWith((services) => InternalEffect.sync(() => self.updateUnsafe(input, services)))
+    InternalEffect.contextWith((services) => InternalEffect.sync(() => self.updateUnsafe(input, services)))
 )
 
 /**
@@ -3506,7 +3506,7 @@ export const mapInput: {
    * @since 2.0.0
    * @category Mapping
    */
-  <Input, Input2 extends Input>(f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input): <State>(self: Metric<Input, State>) => Metric<Input2, State>
+  <Input, Input2 extends Input>(f: (input: Input2, context: Context.Context<never>) => Input): <State>(self: Metric<Input, State>) => Metric<Input2, State>
   /**
    * Returns a new metric that is powered by this one, but which accepts updates
    * of the specified new type, which must be transformable to the input type of
@@ -3547,7 +3547,7 @@ export const mapInput: {
    */
   <Input, State, Input2>(
     self: Metric<Input, State>,
-    f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input
+    f: (input: Input2, context: Context.Context<never>) => Input
   ): Metric<Input2, State>
 } = dual<
   /**
@@ -3588,7 +3588,7 @@ export const mapInput: {
    * @since 2.0.0
    * @category Mapping
    */
-  <Input, Input2 extends Input>(f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input) => <State>(self: Metric<Input, State>) => Metric<Input2, State>,
+  <Input, Input2 extends Input>(f: (input: Input2, context: Context.Context<never>) => Input) => <State>(self: Metric<Input, State>) => Metric<Input2, State>,
   /**
    * Returns a new metric that is powered by this one, but which accepts updates
    * of the specified new type, which must be transformable to the input type of
@@ -3629,11 +3629,11 @@ export const mapInput: {
    */
   <Input, State, Input2>(
     self: Metric<Input, State>,
-    f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input
+    f: (input: Input2, context: Context.Context<never>) => Input
   ) => Metric<Input2, State>
 >(2, <Input, State, Input2>(
   self: Metric<Input, State>,
-  f: (input: Input2, context: ServiceMap.ServiceMap<never>) => Input
+  f: (input: Input2, context: Context.Context<never>) => Input
 ): Metric<Input2, State> =>
   new MetricTransform(
     self,
@@ -4112,9 +4112,9 @@ export const withAttributes: {
 ): Metric<Input, State> =>
   new MetricTransform(
     self,
-    (context) => self.valueUnsafe(addAttributesToServiceMap(context, attributes)),
-    (input, context) => self.updateUnsafe(input, addAttributesToServiceMap(context, attributes)),
-    (input, context) => self.modifyUnsafe(input, addAttributesToServiceMap(context, attributes))
+    (context) => self.valueUnsafe(addAttributesToContext(context, attributes)),
+    (input, context) => self.updateUnsafe(input, addAttributesToContext(context, attributes)),
+    (input, context) => self.modifyUnsafe(input, addAttributesToContext(context, attributes))
   ))
 
 // Metric Snapshots
@@ -4168,7 +4168,7 @@ export const withAttributes: {
  * @category Snapshotting
  */
 export const snapshot: Effect<ReadonlyArray<Metric.Snapshot>> = InternalEffect.map(
-  InternalEffect.services(),
+  InternalEffect.context(),
   (context) => snapshotUnsafe(context)
 )
 
@@ -4226,7 +4226,7 @@ export const snapshot: Effect<ReadonlyArray<Metric.Snapshot>> = InternalEffect.m
  * @since 2.0.0
  * @category Debugging
  */
-export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.services(), (context) => {
+export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.context(), (context) => {
   const metrics = snapshotUnsafe(context)
   if (metrics.length > 0) {
     const maxNameLength = metrics.reduce((max, metric) => {
@@ -4292,7 +4292,7 @@ export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.servic
  *   yield* Metric.update(responseTime, 150)
  *
  *   // Get services context for unsafe operations
- *   const services = yield* Effect.services()
+ *   const services = yield* Effect.context()
  *
  *   // Use snapshotUnsafe for direct, synchronous access
  *   const snapshots = Metric.snapshotUnsafe(services)
@@ -4321,11 +4321,11 @@ export const dump: Effect<string> = InternalEffect.flatMap(InternalEffect.servic
  * @since 2.0.0
  * @category Snapshotting
  */
-export const snapshotUnsafe = (services: ServiceMap.ServiceMap<never>): ReadonlyArray<Metric.Snapshot> => {
-  const registry = ServiceMap.get(services, MetricRegistry)
+export const snapshotUnsafe = (context: Context.Context<never>): ReadonlyArray<Metric.Snapshot> => {
+  const registry = Context.get(context, MetricRegistry)
   return Array.from(registry.values()).map(({ hooks, ...meta }) => ({
     ...meta,
-    state: hooks.get(services)
+    state: hooks.get(context)
   }))
 }
 
@@ -4629,7 +4629,7 @@ export const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMe
  *
  * @example
  * ```ts
- * import type { ServiceMap } from "effect"
+ * import type { Context } from "effect"
  * import { Data, Effect, Layer, Metric } from "effect"
  * import type { Exit } from "effect/Exit"
  *
@@ -4639,12 +4639,12 @@ export const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMe
  *
  * // Custom implementation of the metrics service
  * const customMetricsService: Metric.FiberRuntimeMetricsService = {
- *   recordFiberStart: (context: ServiceMap.ServiceMap<never>) => {
+ *   recordFiberStart: (context: Context.Context<never>) => {
  *     console.log("Fiber started")
  *     // Custom logic for tracking fiber starts
  *   },
  *   recordFiberEnd: (
- *     context: ServiceMap.ServiceMap<never>,
+ *     context: Context.Context<never>,
  *     exit: Exit<unknown, unknown>
  *   ) => {
  *     console.log("Fiber completed with exit:", exit)
@@ -4664,8 +4664,8 @@ export const FiberRuntimeMetricsKey: "effect/observability/Metric/FiberRuntimeMe
  * @category Runtime Metrics
  */
 export interface FiberRuntimeMetricsService {
-  readonly recordFiberStart: (context: ServiceMap.ServiceMap<never>) => void
-  readonly recordFiberEnd: (context: ServiceMap.ServiceMap<never>, exit: Exit<unknown, unknown>) => void
+  readonly recordFiberStart: (context: Context.Context<never>) => void
+  readonly recordFiberEnd: (context: Context.Context<never>, exit: Exit<unknown, unknown>) => void
 }
 
 /**
@@ -4713,7 +4713,7 @@ export interface FiberRuntimeMetricsService {
  * @since 4.0.0
  * @category Runtime Metrics
  */
-export const FiberRuntimeMetrics = ServiceMap.Reference<FiberRuntimeMetricsService | undefined>(
+export const FiberRuntimeMetrics = Context.Reference<FiberRuntimeMetricsService | undefined>(
   InternalMetric.FiberRuntimeMetricsKey,
   { defaultValue: constUndefined }
 )
@@ -4763,11 +4763,11 @@ export const FiberRuntimeMetrics = ServiceMap.Reference<FiberRuntimeMetricsServi
  * @category Runtime Metrics
  */
 export const FiberRuntimeMetricsImpl: FiberRuntimeMetricsService = {
-  recordFiberStart(context: ServiceMap.ServiceMap<never>) {
+  recordFiberStart(context: Context.Context<never>) {
     fibersStarted.updateUnsafe(1, context)
     fibersActive.modifyUnsafe(1, context)
   },
-  recordFiberEnd(context: ServiceMap.ServiceMap<never>, exit: Exit<unknown, unknown>) {
+  recordFiberEnd(context: Context.Context<never>, exit: Exit<unknown, unknown>) {
     fibersActive.modifyUnsafe(-1, context)
     if (InternalEffect.exitIsSuccess(exit)) {
       fiberSuccesses.updateUnsafe(1, context)
@@ -4801,7 +4801,7 @@ export const FiberRuntimeMetricsImpl: FiberRuntimeMetricsService = {
  *     Effect.gen(function*() {
  *       yield* Effect.sleep(`${50 + id * 10} millis`)
  *       if (id % 7 === 0) {
- *         yield* Effect.fail(new AppError({ operation: `fetch-user-${id}` }))
+ *         return yield* new AppError({ operation: `fetch-user-${id}` })
  *       }
  *       return { id, name: `User ${id}`, email: `user${id}@example.com` }
  *     })
@@ -4940,9 +4940,7 @@ export const disableRuntimeMetricsLayer = Layer.succeed(FiberRuntimeMetrics)(und
  *         yield* Effect.sleep(`${100 + i * 50} millis`)
  *         if (i % 4 === 0) {
  *           // Simulate some failures
- *           yield* Effect.fail(
- *             new RuntimeMetricsError({ operation: `task-${i}` })
- *           )
+ *           return yield* new RuntimeMetricsError({ operation: `task-${i}` })
  *         }
  *         return `Task ${i} completed`
  *       }).pipe(
@@ -5104,9 +5102,9 @@ function makeKey<Input, State>(
 }
 
 function makeHooks<Input, State>(
-  get: (context: ServiceMap.ServiceMap<never>) => State,
-  update: (input: Input, context: ServiceMap.ServiceMap<never>) => void,
-  modify?: (input: Input, context: ServiceMap.ServiceMap<never>) => void
+  get: (context: Context.Context<never>) => State,
+  update: (input: Input, context: Context.Context<never>) => void,
+  modify?: (input: Input, context: Context.Context<never>) => void
 ): Metric.Hooks<Input, State> {
   return { get, update, modify: modify ?? update }
 }
@@ -5136,11 +5134,11 @@ function attributesToRecord(attributes?: Metric.Attributes): Metric.AttributeSet
   return attributes as Metric.AttributeSet | undefined
 }
 
-function addAttributesToServiceMap(
-  context: ServiceMap.ServiceMap<never>,
+function addAttributesToContext(
+  context: Context.Context<never>,
   attributes: Metric.Attributes
-): ServiceMap.ServiceMap<never> {
-  const current = ServiceMap.get(context, CurrentMetricAttributes)
+): Context.Context<never> {
+  const current = Context.get(context, CurrentMetricAttributes)
   const updated = mergeAttributes(current, attributes)
-  return ServiceMap.add(context, CurrentMetricAttributes, updated)
+  return Context.add(context, CurrentMetricAttributes, updated)
 }

package/src/MutableHashMap.ts

@@ -33,6 +33,7 @@ import { type Inspectable, NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 
 const TypeId = "~effect/collections/MutableHashMap"
 
@@ -71,6 +72,14 @@ export interface MutableHashMap<out K, out V> extends Iterable<[K, V]>, Pipeable
   readonly buckets: Map<number, NonEmptyArray<K>>
 }
 
+/**
+ * Checks if the specified value is a `MutableHashMap`, `false` otherwise.
+ *
+ * @category refinements
+ * @since 4.0.0
+ */
+export const isMutableHashMap = <K, V>(value: unknown): value is MutableHashMap<K, V> => hasProperty(value, TypeId)
+
 const MutableHashMapProto: Omit<MutableHashMap<unknown, unknown>, "backing" | "buckets" | "bucketsSize"> = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: MutableHashMap<unknown, unknown>): Iterator<[unknown, unknown]> {

package/src/MutableHashSet.ts

@@ -30,6 +30,7 @@ import { type Inspectable, NodeInspectSymbol, toJson } from "./Inspectable.ts"
 import * as MutableHashMap from "./MutableHashMap.ts"
 import type { Pipeable } from "./Pipeable.ts"
 import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 
 const TypeId = "~effect/collections/MutableHashSet"
 
@@ -68,6 +69,14 @@ export interface MutableHashSet<out V> extends Iterable<V>, Pipeable, Inspectabl
   readonly keyMap: MutableHashMap.MutableHashMap<V, boolean>
 }
 
+/**
+ * Checks if the specified value is a `MutableHashSet`, `false` otherwise.
+ *
+ * @category refinements
+ * @since 4.0.0
+ */
+export const isMutableHashSet = <V>(value: unknown): value is MutableHashSet<V> => hasProperty(value, TypeId)
+
 const MutableHashSetProto: Omit<MutableHashSet<unknown>, "keyMap"> = {
   [TypeId]: TypeId,
   [Symbol.iterator](this: MutableHashSet<unknown>): Iterator<unknown> {

package/src/MutableList.ts

@@ -507,6 +507,9 @@ export const appendAll = <A>(self: MutableList<A>, messages: Iterable<A>): numbe
  * @category mutations
  */
 export const appendAllUnsafe = <A>(self: MutableList<A>, messages: ReadonlyArray<A>, mutable = false): number => {
+  if (messages.length === 0) {
+    return 0
+  }
   const chunk: MutableList.Bucket<A> = {
     array: messages as Array<A>,
     mutable,