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

package/src/SubscriptionRef.ts

@@ -6,8 +6,9 @@ import { dual, identity } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import type { Pipeable } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 import * as PubSub from "./PubSub.ts"
-import * as Ref from "./Ref.ts"
+import * as Semaphore from "./Semaphore.ts"
 import * as Stream from "./Stream.ts"
 import type { Invariant } from "./Types.ts"
 
@@ -18,8 +19,8 @@ const TypeId = "~effect/SubscriptionRef"
  * @category models
  */
 export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>, Pipeable {
-  readonly backing: Ref.Ref<A>
-  readonly semaphore: Effect.Semaphore
+  value: A
+  readonly semaphore: Semaphore.Semaphore
   readonly pubsub: PubSub.PubSub<A>
 }
 
@@ -29,7 +30,7 @@ export interface SubscriptionRef<in out A> extends SubscriptionRef.Variance<A>,
  */
 export const isSubscriptionRef: (u: unknown) => u is SubscriptionRef<unknown> = (
   u: unknown
-): u is SubscriptionRef<unknown> => typeof u === "object" && u != null && TypeId in u
+): u is SubscriptionRef<unknown> => hasProperty(u, TypeId)
 
 /**
  * The `SynchronizedRef` namespace containing type definitions and utilities.
@@ -56,7 +57,7 @@ const Proto = {
   toJSON(this: SubscriptionRef<unknown>) {
     return {
       _id: "SubscriptionRef",
-      value: this.backing.ref.current
+      value: this.value
     }
   }
 }
@@ -70,8 +71,8 @@ const Proto = {
 export const make = <A>(value: A): Effect.Effect<SubscriptionRef<A>> =>
   Effect.map(PubSub.unbounded<A>({ replay: 1 }), (pubsub) => {
     const self = Object.create(Proto)
-    self.semaphore = Effect.makeSemaphoreUnsafe(1)
-    self.backing = Ref.makeUnsafe(value)
+    self.semaphore = Semaphore.makeUnsafe(1)
+    self.value = value
     self.pubsub = pubsub
     PubSub.publishUnsafe(self.pubsub, value)
     return self
@@ -130,7 +131,7 @@ export const changes = <A>(self: SubscriptionRef<A>): Stream.Stream<A> => Stream
  * @since 2.0.0
  * @category getters
  */
-export const getUnsafe = <A>(self: SubscriptionRef<A>): A => self.backing.ref.current
+export const getUnsafe = <A>(self: SubscriptionRef<A>): A => self.value
 
 /**
  * Retrieves the current value of the `SubscriptionRef`.
@@ -150,7 +151,7 @@ export const getUnsafe = <A>(self: SubscriptionRef<A>): A => self.backing.ref.cu
  * @since 2.0.0
  * @category getters
  */
-export const get = <A>(self: SubscriptionRef<A>): Effect.Effect<A> => Effect.sync(() => getUnsafe(self))
+export const get = <A>(self: SubscriptionRef<A>): Effect.Effect<A> => Effect.sync(() => self.value)
 
 /**
  * Atomically retrieves the current value and sets a new value, notifying
@@ -222,10 +223,16 @@ export const getAndSet: {
    */
   <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, value: A) =>
-  self.semaphore.withPermit(Effect.flatMap(
-    Ref.getAndSet(self.backing, value),
-    (oldValue) => Effect.as(PubSub.publish(self.pubsub, value), oldValue)
-  )))
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
+    setUnsafe(self, value)
+    return current
+  })))
+
+const setUnsafe = <A>(self: SubscriptionRef<A>, value: A) => {
+  self.value = value
+  PubSub.publishUnsafe(self.pubsub, value)
+}
 
 /**
  * Atomically retrieves the current value and updates it with the result of
@@ -297,11 +304,11 @@ export const getAndUpdate: {
    */
   <A>(self: SubscriptionRef<A>, update: (a: A) => A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
     const newValue = update(current)
-    self.backing.ref.current = newValue
-    return Effect.as(PubSub.publish(self.pubsub, newValue), current)
+    setUnsafe(self, newValue)
+    return current
   })))
 
 /**
@@ -386,11 +393,11 @@ export const getAndUpdateEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<A, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (newValue) => {
-      self.backing.ref.current = newValue
-      return Effect.as(PubSub.publish(self.pubsub, newValue), current)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
+    return Effect.map(update(current), (newValue) => {
+      setUnsafe(self, newValue)
+      return current
     })
   })))
 
@@ -479,14 +486,14 @@ export const getAndUpdateSome: {
   self: SubscriptionRef<A>,
   update: (a: A) => Option.Option<A>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
     const option = update(current)
     if (Option.isNone(option)) {
       return Effect.succeed(current)
     }
-    self.backing.ref.current = option.value
-    return Effect.map(PubSub.publish(self.pubsub, option.value), () => current)
+    setUnsafe(self, option.value)
+    return current
   })))
 
 /**
@@ -578,13 +585,11 @@ export const getAndUpdateSomeEffect: {
   update: (a: A) => Effect.Effect<Option.Option<A>, E, R>
 ) =>
   self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (option) => {
-      if (Option.isNone(option)) {
-        return Effect.succeed(current)
-      }
-      self.backing.ref.current = option.value
-      return Effect.as(PubSub.publish(self.pubsub, option.value), current)
+    const current = self.value
+    return Effect.map(update(current), (option) => {
+      if (Option.isNone(option)) return current
+      setUnsafe(self, option.value)
+      return current
     })
   })))
 
@@ -670,10 +675,10 @@ export const modify: {
   self: SubscriptionRef<A>,
   modify: (a: A) => readonly [B, A]
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const [b, newValue] = modify(self.backing.ref.current)
-    self.backing.ref.current = newValue
-    return Effect.as(PubSub.publish(self.pubsub, newValue), b)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const [b, newValue] = modify(self.value)
+    setUnsafe(self, newValue)
+    return b
   })))
 
 /**
@@ -764,13 +769,12 @@ export const modifyEffect: {
   self: SubscriptionRef<A>,
   modify: (a: A) => Effect.Effect<readonly [B, A], E, R>
 ): Effect.Effect<B, E, R> =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(modify(current), ([b, newValue]) => {
-      self.backing.ref.current = newValue
-      return Effect.as(PubSub.publish(self.pubsub, newValue), b)
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(modify(self.value), ([b, newValue]) => {
+      setUnsafe(self, newValue)
+      return b
     })
-  })))
+  )))
 
 /**
  * Atomically modifies the `SubscriptionRef` with a function that computes a
@@ -860,13 +864,11 @@ export const modifySome: {
   self: SubscriptionRef<A>,
   modify: (a: A) => readonly [B, Option.Option<A>]
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const [b, option] = modify(self.backing.ref.current)
-    if (Option.isNone(option)) {
-      return Effect.succeed(b)
-    }
-    self.backing.ref.current = option.value
-    return Effect.as(PubSub.publish(self.pubsub, option.value), b)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const [b, option] = modify(self.value)
+    if (Option.isNone(option)) return b
+    setUnsafe(self, option.value)
+    return b
   })))
 
 /**
@@ -972,16 +974,13 @@ export const modifySomeEffect: {
   self: SubscriptionRef<A>,
   modify: (a: A) => Effect.Effect<readonly [B, Option.Option<A>], E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(modify(current), ([b, option]) => {
-      if (Option.isNone(option)) {
-        return Effect.succeed(b)
-      }
-      self.backing.ref.current = option.value
-      return Effect.as(PubSub.publish(self.pubsub, option.value), b)
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(modify(self.value), ([b, option]) => {
+      if (Option.isNone(option)) return b
+      setUnsafe(self, option.value)
+      return b
     })
-  })))
+  )))
 
 /**
  * Sets the value of the `SubscriptionRef`, notifying all subscribers of the
@@ -1049,11 +1048,10 @@ export const set: {
    * @category setters
    */
   <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<void>
-} = dual(2, <A>(self: SubscriptionRef<A>, value: A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    self.backing.ref.current = value
-    return Effect.asVoid(PubSub.publish(self.pubsub, value))
-  })))
+} = dual(
+  2,
+  <A>(self: SubscriptionRef<A>, value: A) => self.semaphore.withPermit(Effect.sync(() => setUnsafe(self, value)))
+)
 
 /**
  * Sets the value of the `SubscriptionRef` and returns the new value,
@@ -1116,9 +1114,9 @@ export const setAndGet: {
    */
   <A>(self: SubscriptionRef<A>, value: A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, value: A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    self.backing.ref.current = value
-    return Effect.map(PubSub.publish(self.pubsub, value), () => value)
+  self.semaphore.withPermit(Effect.sync(() => {
+    setUnsafe(self, value)
+    return value
   })))
 
 /**
@@ -1187,12 +1185,11 @@ export const update: {
    * @category updating
    */
   <A>(self: SubscriptionRef<A>, update: (a: A) => A): Effect.Effect<void>
-} = dual(2, <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const newValue = update(self.backing.ref.current)
-    self.backing.ref.current = newValue
-    return Effect.asVoid(PubSub.publish(self.pubsub, newValue))
-  })))
+} = dual(
+  2,
+  <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
+    self.semaphore.withPermit(Effect.sync(() => setUnsafe(self, update(self.value))))
+)
 
 /**
  * Updates the value of the `SubscriptionRef` with the result of applying an
@@ -1264,13 +1261,9 @@ export const updateEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<A, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (newValue) => {
-      self.backing.ref.current = newValue
-      return Effect.asVoid(PubSub.publish(self.pubsub, newValue))
-    })
-  })))
+  self.semaphore.withPermit(
+    Effect.suspend(() => Effect.map(update(self.value), (newValue) => setUnsafe(self, newValue)))
+  ))
 
 /**
  * Updates the value of the `SubscriptionRef` with the result of applying a
@@ -1333,10 +1326,10 @@ export const updateAndGet: {
    */
   <A>(self: SubscriptionRef<A>, update: (a: A) => A): Effect.Effect<A>
 } = dual(2, <A>(self: SubscriptionRef<A>, update: (a: A) => A) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const newValue = update(self.backing.ref.current)
-    self.backing.ref.current = newValue
-    return Effect.as(PubSub.publish(self.pubsub, newValue), newValue)
+  self.semaphore.withPermit(Effect.sync(() => {
+    const newValue = update(self.value)
+    setUnsafe(self, newValue)
+    return newValue
   })))
 
 /**
@@ -1415,13 +1408,12 @@ export const updateAndGetEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<A, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (newValue) => {
-      self.backing.ref.current = newValue
-      return Effect.as(PubSub.publish(self.pubsub, newValue), newValue)
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(update(self.value), (newValue) => {
+      setUnsafe(self, newValue)
+      return newValue
     })
-  })))
+  )))
 
 /**
  * Optionally updates the value of the `SubscriptionRef` with the result of
@@ -1505,13 +1497,10 @@ export const updateSome: {
   self: SubscriptionRef<A>,
   update: (a: A) => Option.Option<A>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const option = update(self.backing.ref.current)
-    if (Option.isNone(option)) {
-      return Effect.void
-    }
-    self.backing.ref.current = option.value
-    return Effect.asVoid(PubSub.publish(self.pubsub, option.value))
+  self.semaphore.withPermit(Effect.sync(() => {
+    const option = update(self.value)
+    if (Option.isNone(option)) return
+    setUnsafe(self, option.value)
   })))
 
 /**
@@ -1599,16 +1588,12 @@ export const updateSomeEffect: {
   self: SubscriptionRef<A>,
   update: (a: A) => Effect.Effect<Option.Option<A>, E, R>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (option) => {
-      if (Option.isNone(option)) {
-        return Effect.void
-      }
-      self.backing.ref.current = option.value
-      return Effect.asVoid(PubSub.publish(self.pubsub, option.value))
+  self.semaphore.withPermit(Effect.suspend(() =>
+    Effect.map(update(self.value), (option) => {
+      if (Option.isNone(option)) return
+      setUnsafe(self, option.value)
     })
-  })))
+  )))
 
 /**
  * Optionally updates the value of the `SubscriptionRef` with the result of
@@ -1686,14 +1671,12 @@ export const updateSomeAndGet: {
   self: SubscriptionRef<A>,
   update: (a: A) => Option.Option<A>
 ) =>
-  self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
+  self.semaphore.withPermit(Effect.sync(() => {
+    const current = self.value
     const option = update(current)
-    if (Option.isNone(option)) {
-      return Effect.succeed(current)
-    }
-    self.backing.ref.current = option.value
-    return Effect.as(PubSub.publish(self.pubsub, option.value), option.value)
+    if (Option.isNone(option)) return current
+    setUnsafe(self, option.value)
+    return option.value
   })))
 
 /**
@@ -1776,12 +1759,10 @@ export const updateSomeAndGetEffect: {
   update: (a: A) => Effect.Effect<Option.Option<A>, E, R>
 ) =>
   self.semaphore.withPermit(Effect.suspend(() => {
-    const current = self.backing.ref.current
-    return Effect.flatMap(update(current), (option) => {
-      if (Option.isNone(option)) {
-        return Effect.succeed(current)
-      }
-      self.backing.ref.current = option.value
-      return Effect.as(PubSub.publish(self.pubsub, option.value), option.value)
+    const current = self.value
+    return Effect.map(update(current), (option) => {
+      if (Option.isNone(option)) return current
+      setUnsafe(self, option.value)
+      return option.value
     })
   })))

package/src/SynchronizedRef.ts

@@ -6,6 +6,7 @@ import { dual } from "./Function.ts"
 import { PipeInspectableProto } from "./internal/core.ts"
 import * as Option from "./Option.ts"
 import * as Ref from "./Ref.ts"
+import * as Semaphore from "./Semaphore.ts"
 
 const TypeId = "~effect/SynchronizedRef"
 
@@ -16,7 +17,7 @@ const TypeId = "~effect/SynchronizedRef"
 export interface SynchronizedRef<in out A> extends Ref.Ref<A> {
   readonly [TypeId]: typeof TypeId
   readonly backing: Ref.Ref<A>
-  readonly semaphore: Effect.Semaphore
+  readonly semaphore: Semaphore.Semaphore
 }
 
 const Proto = {
@@ -36,7 +37,7 @@ const Proto = {
  */
 export const makeUnsafe = <A>(value: A): SynchronizedRef<A> => {
   const self = Object.create(Proto)
-  self.semaphore = Effect.makeSemaphoreUnsafe(1)
+  self.semaphore = Semaphore.makeUnsafe(1)
   self.backing = Ref.makeUnsafe(value)
   return self
 }

package/src/Terminal.ts

@@ -2,13 +2,14 @@
  * @since 4.0.0
  */
 import type * as Cause from "./Cause.ts"
+import * as Context from "./Context.ts"
 import type * as Effect from "./Effect.ts"
+import type * as Option from "./Option.ts"
 import type { PlatformError } from "./PlatformError.ts"
 import * as Predicate from "./Predicate.ts"
 import type * as Queue from "./Queue.ts"
 import * as Schema from "./Schema.ts"
 import type * as Scope from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/platform/Terminal"
 
@@ -71,7 +72,7 @@ export interface UserInput {
   /**
    * The character read from the user (if any).
    */
-  readonly input: string | undefined
+  readonly input: Option.Option<string>
   /**
    * The key that the user pressed.
    */
@@ -87,7 +88,7 @@ const QuitErrorTypeId = "effect/platform/Terminal/QuitError"
  * @since 4.0.0
  * @category QuitError
  */
-export class QuitError extends Schema.ErrorClass("QuitError")({
+export class QuitError extends Schema.ErrorClass<QuitError>("QuitError")({
   _tag: Schema.tag("QuitError")
 }) {
   /**
@@ -106,7 +107,7 @@ export const isQuitError = (u: unknown): u is QuitError => Predicate.hasProperty
  * @since 4.0.0
  * @category Services
  */
-export const Terminal: ServiceMap.Service<Terminal, Terminal> = ServiceMap.Service("effect/platform/Terminal")
+export const Terminal: Context.Service<Terminal, Terminal> = Context.Service("effect/platform/Terminal")
 
 /**
  * Creates a Terminal implementation

package/src/Tracer.ts

@@ -1,12 +1,13 @@
 /**
  * @since 2.0.0
  */
+import * as Context from "./Context.ts"
 import type * as Exit from "./Exit.ts"
 import type { Fiber } from "./Fiber.ts"
 import { constFalse, type LazyArg } from "./Function.ts"
 import type * as core from "./internal/core.ts"
 import type { LogLevel } from "./LogLevel.ts"
-import * as ServiceMap from "./ServiceMap.ts"
+import * as Option from "./Option.ts"
 
 /**
  * @since 2.0.0
@@ -15,8 +16,8 @@ import * as ServiceMap from "./ServiceMap.ts"
 export interface Tracer {
   span(this: Tracer, options: {
     readonly name: string
-    readonly parent: AnySpan | undefined
-    readonly annotations: ServiceMap.ServiceMap<never>
+    readonly parent: Option.Option<AnySpan>
+    readonly annotations: Context.Context<never>
     readonly links: Array<SpanLink>
     readonly startTime: bigint
     readonly kind: SpanKind
@@ -100,7 +101,7 @@ export type AnySpan = Span | ExternalSpan
  * ```ts
  * import { Tracer } from "effect"
  *
- * // The key used to identify parent spans in the service map
+ * // The key used to identify parent spans in the context
  * console.log(Tracer.ParentSpanKey) // "effect/Tracer/ParentSpan"
  * ```
  */
@@ -120,7 +121,7 @@ export const ParentSpanKey = "effect/Tracer/ParentSpan"
  * })
  * ```
  */
-export class ParentSpan extends ServiceMap.Service<ParentSpan, AnySpan>()(ParentSpanKey) {}
+export class ParentSpan extends Context.Service<ParentSpan, AnySpan>()(ParentSpanKey) {}
 
 /**
  * @since 2.0.0
@@ -128,7 +129,7 @@ export class ParentSpan extends ServiceMap.Service<ParentSpan, AnySpan>()(Parent
  * @example
  * ```ts
  * import type { Tracer } from "effect"
- * import { ServiceMap } from "effect"
+ * import { Context } from "effect"
  *
  * // Create an external span from another tracing system
  * const externalSpan: Tracer.ExternalSpan = {
@@ -136,7 +137,7 @@ export class ParentSpan extends ServiceMap.Service<ParentSpan, AnySpan>()(Parent
  *   spanId: "span-abc-123",
  *   traceId: "trace-xyz-789",
  *   sampled: true,
- *   annotations: ServiceMap.empty()
+ *   annotations: Context.empty()
  * }
  *
  * console.log(`External span: ${externalSpan.spanId}`)
@@ -147,7 +148,7 @@ export interface ExternalSpan {
   readonly spanId: string
   readonly traceId: string
   readonly sampled: boolean
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly annotations: Context.Context<never>
 }
 
 /**
@@ -182,7 +183,7 @@ export interface SpanOptionsNoTrace {
   readonly links?: ReadonlyArray<SpanLink> | undefined
   readonly parent?: AnySpan | undefined
   readonly root?: boolean | undefined
-  readonly annotations?: ServiceMap.ServiceMap<never> | undefined
+  readonly annotations?: Context.Context<never> | undefined
   readonly kind?: SpanKind | undefined
   readonly sampled?: boolean | undefined
   readonly level?: LogLevel | undefined
@@ -241,8 +242,8 @@ export interface Span {
   readonly name: string
   readonly spanId: string
   readonly traceId: string
-  readonly parent: AnySpan | undefined
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly parent: Option.Option<AnySpan>
+  readonly annotations: Context.Context<never>
   readonly status: SpanStatus
   readonly attributes: ReadonlyMap<string, unknown>
   readonly links: ReadonlyArray<SpanLink>
@@ -313,14 +314,14 @@ export const externalSpan = (
     readonly spanId: string
     readonly traceId: string
     readonly sampled?: boolean | undefined
-    readonly annotations?: ServiceMap.ServiceMap<never> | undefined
+    readonly annotations?: Context.Context<never> | undefined
   }
 ): ExternalSpan => ({
   _tag: "ExternalSpan",
   spanId: options.spanId,
   traceId: options.traceId,
   sampled: options.sampled ?? true,
-  annotations: options.annotations ?? ServiceMap.empty()
+  annotations: options.annotations ?? Context.empty()
 })
 
 /**
@@ -338,7 +339,7 @@ export const externalSpan = (
  * )
  * ```
  */
-export const DisablePropagation = ServiceMap.Reference<boolean>(
+export const DisablePropagation = Context.Reference<boolean>(
   "effect/Tracer/DisablePropagation",
   { defaultValue: constFalse }
 )
@@ -349,7 +350,7 @@ export const DisablePropagation = ServiceMap.Reference<boolean>(
  * @category references
  * @since 4.0.0
  */
-export const CurrentTraceLevel: ServiceMap.Reference<LogLevel> = ServiceMap.Reference<LogLevel>(
+export const CurrentTraceLevel: Context.Reference<LogLevel> = Context.Reference<LogLevel>(
   "effect/Tracer/CurrentTraceLevel",
   { defaultValue: () => "Info" }
 )
@@ -362,7 +363,7 @@ export const CurrentTraceLevel: ServiceMap.Reference<LogLevel> = ServiceMap.Refe
  * @category references
  * @since 4.0.0
  */
-export const MinimumTraceLevel = ServiceMap.Reference<
+export const MinimumTraceLevel = Context.Reference<
   LogLevel
 >("effect/Tracer/MinimumTraceLevel", { defaultValue: () => "All" })
 
@@ -392,7 +393,7 @@ export const TracerKey = "effect/Tracer"
  * })
  * ```
  */
-export const Tracer: ServiceMap.Reference<Tracer> = ServiceMap.Reference<Tracer>(TracerKey, {
+export const Tracer: Context.Reference<Tracer> = Context.Reference<Tracer>(TracerKey, {
   defaultValue: () =>
     make({
       span: (options) => new NativeSpan(options)
@@ -410,8 +411,8 @@ export class NativeSpan implements Span {
   readonly sampled: boolean
 
   readonly name: string
-  readonly parent: AnySpan | undefined
-  readonly annotations: ServiceMap.ServiceMap<never>
+  readonly parent: Option.Option<AnySpan>
+  readonly annotations: Context.Context<never>
   readonly links: Array<SpanLink>
   readonly startTime: bigint
   readonly kind: SpanKind
@@ -422,8 +423,8 @@ export class NativeSpan implements Span {
 
   constructor(options: {
     readonly name: string
-    readonly parent: AnySpan | undefined
-    readonly annotations: ServiceMap.ServiceMap<never>
+    readonly parent: Option.Option<AnySpan>
+    readonly annotations: Context.Context<never>
     readonly links: Array<SpanLink>
     readonly startTime: bigint
     readonly kind: SpanKind
@@ -441,7 +442,7 @@ export class NativeSpan implements Span {
       startTime: options.startTime
     }
     this.attributes = new Map()
-    this.traceId = options.parent?.traceId ?? randomHexString(32)
+    this.traceId = Option.getOrUndefined(options.parent)?.traceId ?? randomHexString(32)
     this.spanId = randomHexString(16)
   }