effect 4.0.0-beta.43 → 4.0.0-beta.44

package/src/Redactable.ts

@@ -1,111 +1,171 @@
 /**
- * @since 4.0.0
- */
-import { pipeArguments } from "./Pipeable.ts"
-import { hasProperty } from "./Predicate.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
-
-/**
- * Symbol used to identify objects that implement redaction capabilities.
+ * Context-aware redaction for sensitive values.
  *
- * @since 4.0.0
- * @category symbol
- */
-export const symbolRedactable: unique symbol = Symbol.for("~effect/Inspectable/redactable")
-
-/**
- * Interface for objects that can provide redacted representations.
+ * The `Redactable` module provides a protocol for objects that need to present
+ * alternative representations of themselves depending on the runtime context.
+ * Typical use cases include masking secrets, tokens, or personal data in logs, traces,
+ * and serialized output.
+ *
+ * ## Mental model
+ *
+ * - **Redactable** - an object that implements `[symbolRedactable]`, a method
+ *   that receives the current `Context` and returns a replacement value.
+ * - **symbolRedactable** - the well-known `Symbol` key that marks an object as
+ *   redactable.
+ * - **redact** - the primary entry point: pass any value and get back either its
+ *   redacted form (if it is `Redactable`) or the original value unchanged.
+ * - **getRedacted** - lower-level helper that calls `[symbolRedactable]` directly
+ *   on a value already known to be `Redactable`.
+ * - The `Context` passed to `[symbolRedactable]` comes from the current fiber.
+ *   If no fiber is active, an empty `Context` is used.
+ *
+ * ## Common tasks
  *
- * Redactable objects can provide different representations of themselves based on
- * the current execution context. This is useful for sensitive data that should
- * be hidden or modified in certain environments (like production logs).
+ * - **Make a value redactable**: implement the {@link Redactable} interface by
+ *   adding a `[symbolRedactable]` method.
+ * - **Redact an unknown value**: call {@link redact} - it returns the original
+ *   value when it is not redactable.
+ * - **Check if a value is redactable**: use {@link isRedactable}.
+ * - **Get the redacted form of a known `Redactable`**: use {@link getRedacted}.
+ *
+ * ## Gotchas
+ *
+ * - `[symbolRedactable]` receives the fiber's `Context` as its argument.
+ * - Outside of an Effect runtime (no current fiber), `getRedacted` still works
+ *   but passes an empty `Context`, so service lookups will not find anything.
+ * - `redact` is not recursive: if a redactable object contains nested
+ *   redactable values, only the outermost redaction is applied.
+ *
+ * ## Quickstart
+ *
+ * **Example** (Masking an API key)
  *
- * @example
  * ```ts
- * import type { ServiceMap } from "effect"
- * import { Redactable } from "effect"
+ * import { Context, Redactable } from "effect"
  *
- * class SensitiveData implements Redactable.Redactable {
- *   constructor(private secret: string) {}
+ * class ApiKey {
+ *   constructor(readonly raw: string) {}
  *
- *   [Redactable.symbolRedactable](context: ServiceMap.ServiceMap<never>) {
- *     // In production, hide the actual secret
- *     return { secret: "[REDACTED]" }
+ *   [Redactable.symbolRedactable](_ctx: Context.Context<never>) {
+ *     return this.raw.slice(0, 4) + "..."
  *   }
  * }
  *
- * const data = new SensitiveData("my-secret-key")
- * // The redacted version will be used when converting to JSON in certain contexts
+ * const key = new ApiKey("sk-1234567890abcdef")
+ *
+ * console.log(Redactable.isRedactable(key))  // true
+ * console.log(Redactable.redact(key))         // "sk-1..."
+ * console.log(Redactable.redact("plain"))     // "plain"
  * ```
  *
+ * ## See also
+ *
+ * - {@link Redactable} - the interface to implement
+ * - {@link symbolRedactable} - the symbol key
+ * - {@link redact} - the main redaction entry point
+ *
  * @since 4.0.0
- * @category Model
  */
-export interface Redactable {
-  readonly [symbolRedactable]: (context: ServiceMap.ServiceMap<never>) => unknown
-}
+import type * as Context from "./Context.ts"
+import { pipeArguments } from "./Pipeable.ts"
+import { hasProperty } from "./Predicate.ts"
 
 /**
- * Checks if a value implements the `Redactable` interface.
+ * Symbol used to identify objects that implement the {@link Redactable}
+ * protocol.
+ *
+ * Add a method under this key to make an object redactable. The method
+ * receives the current `Context` and must return the replacement value.
  *
- * This function determines whether a given value has redaction capabilities,
- * meaning it can provide alternative representations based on context.
+ * - Use this symbol as the property key when implementing {@link Redactable}.
+ * - Registered globally via `Symbol.for("~effect/Redactable")`,
+ *   so it is identical across multiple copies of the library at runtime.
  *
- * @param u - The value to check
+ * **Example** (Masking an API key)
  *
- * @example
  * ```ts
- * import { Redactable } from "effect"
+ * import { Context, Redactable } from "effect"
  *
- * class RedactableSecret {
- *   [Redactable.symbolRedactable]() {
- *     return "[REDACTED]"
+ * class ApiKey {
+ *   constructor(readonly raw: string) {}
+ *
+ *   [Redactable.symbolRedactable](_ctx: Context.Context<never>) {
+ *     return this.raw.slice(0, 4) + "..."
  *   }
  * }
- *
- * const secret = new RedactableSecret()
- * const normal = { value: 42 }
- *
- * console.log(Redactable.isRedactable(secret)) // true
- * console.log(Redactable.isRedactable(normal)) // false
- * console.log(Redactable.isRedactable("string")) // false
  * ```
  *
+ * See also:
+ * - {@link Redactable} - the interface this symbol belongs to
+ * - {@link isRedactable} - check whether a value has this symbol
+ *
  * @since 4.0.0
- * @category redactable
+ * @category symbol
  */
-export const isRedactable = (u: unknown): u is Redactable => hasProperty(u, symbolRedactable)
+export const symbolRedactable: unique symbol = Symbol.for("~effect/Redactable")
 
 /**
- * Applies redaction to a value if it implements the Redactable interface.
+ * Interface for objects that provide context-aware redacted representations.
  *
- * This function checks if the value is redactable and applies the redaction
- * transformation if a current fiber context is available. Otherwise, it returns
- * the value unchanged.
+ * - Implement this interface on any class or object that holds sensitive data
+ *   and should present a sanitized form when inspected or logged.
+ * - The `[symbolRedactable]` method receives the current fiber's `Context`.
+ * - If no fiber is active, an empty `Context` is provided.
  *
- * @param u - The value to potentially redact
+ * **Example** (Masking an API key)
  *
- * @example
  * ```ts
- * import { Redactable } from "effect"
+ * import { Context, Redactable } from "effect"
  *
- * class CreditCard {
- *   constructor(private number: string) {}
+ * class ApiKey {
+ *   constructor(readonly raw: string) {}
  *
- *   [Redactable.symbolRedactable]() {
- *     return {
- *       number: this.number.slice(0, 4) + "****"
- *     }
+ *   [Redactable.symbolRedactable](_ctx: Context.Context<never>) {
+ *     return this.raw.slice(0, 4) + "..."
  *   }
  * }
+ * ```
  *
- * const card = new CreditCard("1234567890123456")
- * console.log(Redactable.redact(card)) // { number: "1234****" }
+ * See also:
+ * - {@link symbolRedactable} - the symbol key to implement
+ * - {@link redact} - apply redaction to any value
+ * - {@link isRedactable} - type guard for this interface
  *
- * // Non-redactable values are returned unchanged
- * console.log(Redactable.redact("normal string")) // "normal string"
- * console.log(Redactable.redact({ id: 123 })) // { id: 123 }
- * ```
+ * @since 4.0.0
+ * @category Model
+ */
+export interface Redactable {
+  readonly [symbolRedactable]: (context: Context.Context<never>) => unknown
+}
+
+/**
+ * Type guard that checks whether a value implements the {@link Redactable}
+ * interface.
+ *
+ * See also:
+ * - {@link Redactable} - the interface being checked
+ * - {@link redact} - applies redaction if the value is redactable
+ *
+ * @since 4.0.0
+ * @category guards
+ */
+export const isRedactable = (u: unknown): u is Redactable => hasProperty(u, symbolRedactable)
+
+/**
+ * Redacts a value if it implements {@link Redactable}, otherwise returns it
+ * unchanged.
+ *
+ * - Use this as the general-purpose entry point for redaction: it is safe to
+ *   call on any value.
+ * - Internally calls {@link isRedactable} and, if `true`, delegates to
+ *   {@link getRedacted}.
+ * - Not recursive: nested redactable values inside the returned object are not
+ *   automatically redacted.
+ * - Pure with respect to its argument (does not mutate the input).
+ *
+ * See also:
+ * - {@link isRedactable} - check before redacting
+ * - {@link getRedacted} - lower-level variant for known redactables
  *
  * @since 4.0.0
  */
@@ -115,17 +175,31 @@ export function redact(u: unknown): unknown {
 }
 
 /**
+ * Calls `[symbolRedactable]` on a value that is already known to be
+ * {@link Redactable} and returns the result.
+ *
+ * - Use this when you have already verified the value is `Redactable` (e.g.,
+ *   via {@link isRedactable}) and want to avoid a second check.
+ * - Reads the current fiber's `Context` from the global fiber reference. If
+ *   no fiber is active, an empty `Context` is passed to the redaction
+ *   method.
+ * - Does not mutate the input.
+ *
+ * See also:
+ * - {@link redact} - higher-level variant that handles non-redactable values
+ * - {@link isRedactable} - type guard to verify before calling this
+ *
  * @since 4.0.0
  */
 export function getRedacted(redactable: Redactable): unknown {
-  return redactable[symbolRedactable]((globalThis as any)[currentFiberTypeId]?.services ?? emptyServiceMap)
+  return redactable[symbolRedactable]((globalThis as any)[currentFiberTypeId]?.context ?? emptyContext)
 }
 
 /** @internal */
 export const currentFiberTypeId = "~effect/Fiber/currentFiber"
 
-const emptyServiceMap: ServiceMap.ServiceMap<never> = {
-  "~effect/ServiceMap": {} as any,
+const emptyContext: Context.Context<never> = {
+  "~effect/Context": {} as any,
   mapUnsafe: new Map(),
   pipe() {
     return pipeArguments(this, arguments)

package/src/References.ts

@@ -10,13 +10,13 @@
  *
  * @since 4.0.0
  */
+import type * as Context from "./Context.ts"
 import * as internalEffect from "./internal/effect.ts"
 import * as references from "./internal/references.ts"
 import type { Logger } from "./Logger.ts"
 import type { LogLevel, Severity } from "./LogLevel.ts"
 import type { ReadonlyRecord } from "./Record.ts"
 import { MaxOpsBeforeYield, PreventSchedulerYield } from "./Scheduler.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 import { CurrentTraceLevel, DisablePropagation, MinimumTraceLevel, type SpanLink, Tracer } from "./Tracer.ts"
 
 export {
@@ -90,7 +90,7 @@ export {
  * @category references
  * @since 4.0.0
  */
-export const CurrentConcurrency: ServiceMap.Reference<number | "unbounded"> = references.CurrentConcurrency
+export const CurrentConcurrency: Context.Reference<number | "unbounded"> = references.CurrentConcurrency
 
 /**
  * Reference for managing log annotations that are automatically added to all log entries.
@@ -146,7 +146,7 @@ export const CurrentConcurrency: ServiceMap.Reference<number | "unbounded"> = re
  * @since 4.0.0
  * @category references
  */
-export const CurrentLogAnnotations: ServiceMap.Reference<ReadonlyRecord<string, unknown>> =
+export const CurrentLogAnnotations: Context.Reference<ReadonlyRecord<string, unknown>> =
   references.CurrentLogAnnotations
 
 /**
@@ -189,7 +189,7 @@ export const CurrentLogAnnotations: ServiceMap.Reference<ReadonlyRecord<string,
  * @category references
  * @since 4.0.0
  */
-export const CurrentLogLevel: ServiceMap.Reference<Severity> = references.CurrentLogLevel
+export const CurrentLogLevel: Context.Reference<Severity> = references.CurrentLogLevel
 
 /**
  * Reference for managing log spans that track the duration and hierarchy of operations.
@@ -249,14 +249,14 @@ export const CurrentLogLevel: ServiceMap.Reference<Severity> = references.Curren
  * @since 4.0.0
  * @category references
  */
-export const CurrentLogSpans: ServiceMap.Reference<ReadonlyArray<[label: string, timestamp: number]>> =
+export const CurrentLogSpans: Context.Reference<ReadonlyArray<[label: string, timestamp: number]>> =
   references.CurrentLogSpans
 
 /**
  * @since 4.0.0
  * @category references
  */
-export const CurrentStackFrame: ServiceMap.Reference<StackFrame | undefined> = references.CurrentStackFrame
+export const CurrentStackFrame: Context.Reference<StackFrame | undefined> = references.CurrentStackFrame
 
 /**
  * Reference for setting the minimum log level threshold. Log entries below this
@@ -307,7 +307,7 @@ export const CurrentStackFrame: ServiceMap.Reference<StackFrame | undefined> = r
  * @category references
  * @since 4.0.0
  */
-export const MinimumLogLevel: ServiceMap.Reference<LogLevel> = references.MinimumLogLevel
+export const MinimumLogLevel: Context.Reference<LogLevel> = references.MinimumLogLevel
 
 /**
  * Reference for controlling whether tracing is enabled globally. When set to false,
@@ -353,7 +353,7 @@ export const MinimumLogLevel: ServiceMap.Reference<LogLevel> = references.Minimu
  * @since 4.0.0
  * @category references
  */
-export const TracerEnabled: ServiceMap.Reference<boolean> = references.TracerEnabled
+export const TracerEnabled: Context.Reference<boolean> = references.TracerEnabled
 
 /**
  * Reference for managing span annotations that are automatically added to all new spans.
@@ -405,7 +405,7 @@ export const TracerEnabled: ServiceMap.Reference<boolean> = references.TracerEna
  * @since 4.0.0
  * @category references
  */
-export const TracerSpanAnnotations: ServiceMap.Reference<ReadonlyRecord<string, unknown>> =
+export const TracerSpanAnnotations: Context.Reference<ReadonlyRecord<string, unknown>> =
   references.TracerSpanAnnotations
 
 /**
@@ -468,7 +468,7 @@ export const TracerSpanAnnotations: ServiceMap.Reference<ReadonlyRecord<string,
  * @since 4.0.0
  * @category references
  */
-export const TracerSpanLinks: ServiceMap.Reference<ReadonlyArray<SpanLink>> = references.TracerSpanLinks
+export const TracerSpanLinks: Context.Reference<ReadonlyArray<SpanLink>> = references.TracerSpanLinks
 
 /**
  * Reference for controlling whether trace timing is enabled globally. When set
@@ -511,7 +511,7 @@ export const TracerSpanLinks: ServiceMap.Reference<ReadonlyArray<SpanLink>> = re
  * @since 4.0.0
  * @category references
  */
-export const TracerTimingEnabled: ServiceMap.Reference<boolean> = references.TracerTimingEnabled
+export const TracerTimingEnabled: Context.Reference<boolean> = references.TracerTimingEnabled
 
 /**
  * The log level for unhandled errors. This reference allows you to set the log
@@ -520,7 +520,7 @@ export const TracerTimingEnabled: ServiceMap.Reference<boolean> = references.Tra
  * @category references
  * @since 4.0.0
  */
-export const UnhandledLogLevel: ServiceMap.Reference<Severity | undefined> = references.UnhandledLogLevel
+export const UnhandledLogLevel: Context.Reference<Severity | undefined> = references.UnhandledLogLevel
 
 /**
  * @since 4.0.0
@@ -536,13 +536,13 @@ export interface StackFrame {
  * @since 4.0.0
  * @category references
  */
-export const CurrentLoggers: ServiceMap.Reference<ReadonlySet<Logger<unknown, any>>> = internalEffect.CurrentLoggers
+export const CurrentLoggers: Context.Reference<ReadonlySet<Logger<unknown, any>>> = internalEffect.CurrentLoggers
 
 /**
  * @since 4.0.0
  * @category references
  */
-export const LogToStderr: ServiceMap.Reference<boolean> = internalEffect.LogToStderr
+export const LogToStderr: Context.Reference<boolean> = internalEffect.LogToStderr
 
 export {
   /**

package/src/Request.ts

@@ -14,6 +14,7 @@
  * @since 2.0.0
  */
 import type * as Cause from "./Cause.ts"
+import type * as Context from "./Context.ts"
 import type * as Effect from "./Effect.ts"
 import * as Equal from "./Equal.ts"
 import type * as Exit from "./Exit.ts"
@@ -21,7 +22,6 @@ import { dual } from "./Function.ts"
 import * as core from "./internal/core.ts"
 import * as internalEffect from "./internal/effect.ts"
 import { hasProperty } from "./Predicate.ts"
-import type * as ServiceMap from "./ServiceMap.ts"
 import type * as Types from "./Types.ts"
 
 const TypeId = "~effect/Request"
@@ -309,10 +309,10 @@ export const tagged = <R extends Request<any, any, any> & { _tag: string }>(
  * @since 2.0.0
  * @category constructors
  */
-export const Class: new<A extends Record<string, any>, Success, Error = never, ServiceMap = never>(
+export const Class: new<A extends Record<string, any>, Success, Error = never, Context = never>(
   args: Types.Equals<Omit<A, keyof Request<unknown, unknown>>, {}> extends true ? void
     : { readonly [P in keyof A as P extends keyof Request<any, any, any> ? never : P]: A[P] }
-) => Request<Success, Error, ServiceMap> & Readonly<A> = (function() {
+) => Request<Success, Error, Context> & Readonly<A> = (function() {
   function Class(this: any, args: any) {
     if (args) {
       Object.assign(this, args)
@@ -472,7 +472,7 @@ export const succeed: {
  */
 export interface Entry<out R> {
   readonly request: R
-  readonly services: ServiceMap.ServiceMap<
+  readonly context: Context.Context<
     [R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never
   >
   uninterruptible: boolean
@@ -490,7 +490,7 @@ export interface Entry<out R> {
  */
 export const makeEntry = <R>(options: {
   readonly request: R
-  readonly services: ServiceMap.ServiceMap<
+  readonly context: Context.Context<
     [R] extends [Request<infer _A, infer _E, infer _R>] ? _R : never
   >
   readonly uninterruptible: boolean

package/src/RequestResolver.ts

@@ -4,6 +4,7 @@
 import type { NonEmptyArray } from "./Array.ts"
 import * as Arr from "./Array.ts"
 import * as Cache from "./Cache.ts"
+import * as Context from "./Context.ts"
 import type * as Duration from "./Duration.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
@@ -18,7 +19,6 @@ import { hasProperty } from "./Predicate.ts"
 import type * as Request from "./Request.ts"
 import type * as Schema from "./Schema.ts"
 import type { Scope } from "./Scope.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import * as Tracer from "./Tracer.ts"
 import type * as Types from "./Types.ts"
 import type * as Persistable from "./unstable/persistence/Persistable.ts"
@@ -1411,7 +1411,7 @@ export const withSpan: {
         const links = opts?.links ? opts.links.slice() : []
         const seen = new Set<Tracer.AnySpan>()
         for (const entry of entries) {
-          const span = ServiceMap.getOption(entry.services, Tracer.ParentSpan)
+          const span = Context.getOption(entry.context, Tracer.ParentSpan)
           if (span._tag === "None" || seen.has(span.value)) continue
           seen.add(span.value)
           links.push({ span: span.value, attributes: {} })
@@ -1505,11 +1505,10 @@ export const asCache: {
   never,
   "construction" extends ServiceMode ? Request.Services<A> : never
 > =>
-  Cache.makeWith({
+  Cache.makeWith((req: A) => internal.request(req, self), {
     capacity: options.capacity,
     timeToLive: options.timeToLive as any,
-    requireServicesAt: options.requireServicesAt ?? "lookup" as ServiceMode,
-    lookup: (req: A) => internal.request(req, self)
+    requireServicesAt: options.requireServicesAt ?? "lookup" as ServiceMode
   }) as any)
 
 /**
@@ -1676,7 +1675,7 @@ export const persisted: {
       ...self,
       runAll: Effect.fnUntraced(function*(entries, key) {
         const results = yield* (store.getMany(Iterable.map(entries, (_) => _.request)).pipe(
-          Effect.provideServices(entries[0].services)
+          Effect.provideContext(entries[0].context)
         ) as Effect.Effect<
           Array<Exit.Exit<unknown, unknown> | undefined>,
           Request.Error<A>
@@ -1712,7 +1711,7 @@ export const persisted: {
           return Effect.void
         })
         yield* (store.setMany(toPersist).pipe(
-          Effect.provideServices(entries[0].services)
+          Effect.provideContext(entries[0].context)
         ) as Effect.Effect<void, Request.Error<A>>)
       })
     });

package/src/Resource.ts

@@ -1,6 +1,7 @@
 /**
  * @since 2.0.0
  */
+import * as Context from "./Context.ts"
 import * as Effect from "./Effect.ts"
 import * as Exit from "./Exit.ts"
 import { identity } from "./Function.ts"
@@ -10,7 +11,6 @@ import { hasProperty } from "./Predicate.ts"
 import type * as Schedule from "./Schedule.ts"
 import type * as Scope from "./Scope.ts"
 import * as ScopedRef from "./ScopedRef.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 const TypeId = "~effect/Resource" as const
 
@@ -64,10 +64,10 @@ const makeUnsafe = <A, E>(
 export const manual = <A, E, R>(
   acquire: Effect.Effect<A, E, R>
 ): Effect.Effect<Resource<A, E>, never, Scope.Scope | R> =>
-  Effect.servicesWith((services: ServiceMap.ServiceMap<R>) => {
-    const providedAcquire = Effect.updateServices(
+  Effect.contextWith((context: Context.Context<R>) => {
+    const providedAcquire = Effect.updateContext(
       acquire,
-      (input: ServiceMap.ServiceMap<never>) => ServiceMap.merge(services, input)
+      (input: Context.Context<never>) => Context.merge(context, input)
     )
     return Effect.map(
       ScopedRef.fromAcquire(Effect.exit(providedAcquire)),

package/src/Schedule.ts

@@ -30,6 +30,7 @@
  * @since 2.0.0
  */
 import * as Cause from "./Cause.ts"
+import * as Context from "./Context.ts"
 import * as Cron from "./Cron.ts"
 import type * as DateTime from "./DateTime.ts"
 import * as Duration from "./Duration.ts"
@@ -43,7 +44,6 @@ import { type Pipeable, pipeArguments } from "./Pipeable.ts"
 import { hasProperty } from "./Predicate.ts"
 import * as Pull from "./Pull.ts"
 import * as Result from "./Result.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 import type { Contravariant, Covariant, Mutable } from "./Types.ts"
 
 const TypeId = "~effect/Schedule"
@@ -166,7 +166,7 @@ export interface Metadata<Output = unknown, Input = unknown> extends InputMetada
  * @since 4.0.0
  * @category Metadata
  */
-export const CurrentMetadata = ServiceMap.Reference<Metadata>("effect/Schedule/CurrentMetadata", {
+export const CurrentMetadata = Context.Reference<Metadata>("effect/Schedule/CurrentMetadata", {
   defaultValue: constant({
     input: undefined,
     output: undefined,

package/src/Scheduler.ts

@@ -1,8 +1,8 @@
 /**
  * @since 2.0.0
  */
+import * as Context from "./Context.ts"
 import type * as Fiber from "./Fiber.ts"
-import * as ServiceMap from "./ServiceMap.ts"
 
 /**
  * A scheduler manages the execution of Effects by controlling when and how tasks
@@ -36,7 +36,7 @@ export interface SchedulerDispatcher {
  * @since 4.0.0
  * @category references
  */
-export const Scheduler: ServiceMap.Reference<Scheduler> = ServiceMap.Reference<Scheduler>("effect/Scheduler", {
+export const Scheduler: Context.Reference<Scheduler> = Context.Reference<Scheduler>("effect/Scheduler", {
   defaultValue: () => new MixedScheduler()
 })
 
@@ -188,7 +188,7 @@ class MixedSchedulerDispatcher implements SchedulerDispatcher {
  * @since 4.0.0
  * @category references
  */
-export const MaxOpsBeforeYield = ServiceMap.Reference<number>("effect/Scheduler/MaxOpsBeforeYield", {
+export const MaxOpsBeforeYield = Context.Reference<number>("effect/Scheduler/MaxOpsBeforeYield", {
   defaultValue: () => 2048
 })
 
@@ -200,6 +200,6 @@ export const MaxOpsBeforeYield = ServiceMap.Reference<number>("effect/Scheduler/
  * @since 4.0.0
  * @category references
  */
-export const PreventSchedulerYield = ServiceMap.Reference<boolean>("effect/Scheduler/PreventSchedulerYield", {
+export const PreventSchedulerYield = Context.Reference<boolean>("effect/Scheduler/PreventSchedulerYield", {
   defaultValue: () => false
 })