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

package/src/unstable/rpc/RpcMiddleware.ts

@@ -1,11 +1,11 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
 import { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Mutable, unhandled } from "../../Types.ts"
 import type { Headers } from "../http/Headers.ts"
 import type * as Rpc from "./Rpc.ts"
@@ -111,8 +111,8 @@ export interface ServiceClass<
   ClientError,
   Requires,
   RequiredForClient extends boolean
-> extends ServiceMap.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
-  new(_: never): ServiceMap.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
+> extends Context.Service<Self, RpcMiddleware<Provides, E["Type"], Requires>> {
+  new(_: never): Context.ServiceClass.Shape<Name, RpcMiddleware<Provides, E["Type"], Requires>> & {
     readonly [TypeId]: {
       readonly error: E
       readonly provides: Provides
@@ -174,7 +174,7 @@ export type ErrorServicesDecode<A> = ErrorSchema<A>["DecodingServices"]
  * @since 4.0.0
  * @category models
  */
-export interface AnyService extends ServiceMap.Key<any, any> {
+export interface AnyService extends Context.Key<any, any> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -185,7 +185,7 @@ export interface AnyService extends ServiceMap.Key<any, any> {
  * @since 4.0.0
  * @category models
  */
-export interface AnyServiceWithProps extends ServiceMap.Key<any, RpcMiddleware<any, any, any>> {
+export interface AnyServiceWithProps extends Context.Key<any, RpcMiddleware<any, any, any>> {
   readonly [TypeId]: typeof TypeId
   readonly error: Schema.Top
   readonly requiredForClient: boolean
@@ -241,7 +241,7 @@ export const Service = <
 
   function ServiceClass() {}
   const ServiceClass_ = ServiceClass as any as Mutable<AnyService>
-  Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(ServiceMap.Service<Self, any>(id)))
+  Object.setPrototypeOf(ServiceClass, Object.getPrototypeOf(Context.Service<Self, any>(id)))
   ServiceClass.key = id
   Object.defineProperty(ServiceClass, "stack", {
     get() {
@@ -259,23 +259,23 @@ export const Service = <
  * @category client
  */
 export const layerClient = <Id extends AnyId, S, R, EX = never, RX = never>(
-  tag: ServiceMap.Key<Id, S>,
+  tag: Context.Key<Id, S>,
   service:
     | RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>
     | Effect.Effect<RpcMiddlewareClient<Id[TypeId]["error"]["Type"], Id[TypeId]["clientError"], R>, EX, RX>
 ): Layer.Layer<ForClient<Id>, EX, R | Exclude<RX, Scope>> =>
-  Layer.effectServices(Effect.gen(function*() {
-    const services = (yield* Effect.services<R | Scope>()).pipe(
-      ServiceMap.omit(Scope)
-    ) as ServiceMap.ServiceMap<R>
+  Layer.effectContext(Effect.gen(function*() {
+    const services = (yield* Effect.context<R | Scope>()).pipe(
+      Context.omit(Scope)
+    ) as Context.Context<R>
     const middleware = Effect.isEffect(service) ? yield* service : service
-    return ServiceMap.makeUnsafe(
+    return Context.makeUnsafe(
       new Map([[
         `${tag.key}/Client`,
         (options: any) =>
-          Effect.updateServices(
+          Effect.updateContext(
             middleware(options),
-            (requestContext) => ServiceMap.merge(services, requestContext)
+            (requestContext) => Context.merge(services, requestContext)
           )
       ]])
     )

package/src/unstable/rpc/RpcSchema.ts

@@ -2,12 +2,12 @@
  * @since 4.0.0
  */
 import * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import { constUndefined } from "../../Function.ts"
 import * as Option from "../../Option.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream_ from "../../Stream.ts"
 
 const StreamSchemaTypeId = "~effect/rpc/RpcSchema/StreamSchema"
@@ -67,9 +67,9 @@ export function Stream<A extends Schema.Top, E extends Schema.Top>(success: A, e
  * @since 4.0.0
  * @category Cause annotations
  */
-export class ClientAbort extends ServiceMap.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
-  static annotation = this.serviceMap(true).pipe(
-    ServiceMap.add(Cause.StackTrace, {
+export class ClientAbort extends Context.Service<ClientAbort, true>()("effect/rpc/RpcSchema/ClientAbort") {
+  static annotation = this.context(true).pipe(
+    Context.add(Cause.StackTrace, {
       name: "ClientAbort",
       stack: constUndefined,
       parent: undefined

package/src/unstable/rpc/RpcSerialization.ts

@@ -2,17 +2,17 @@
  * @since 4.0.0
  */
 import * as Msgpackr from "msgpackr"
+import * as Context from "../../Context.ts"
 import * as Layer from "../../Layer.ts"
 import * as Predicate from "../../Predicate.ts"
 import { hasProperty } from "../../Predicate.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as RpcMessage from "./RpcMessage.ts"
 
 /**
  * @since 4.0.0
  * @category serialization
  */
-export class RpcSerialization extends ServiceMap.Service<RpcSerialization, {
+export class RpcSerialization extends Context.Service<RpcSerialization, {
   makeUnsafe(): Parser
   readonly contentType: string
   readonly includesFraming: boolean

package/src/unstable/rpc/RpcServer.ts

@@ -3,6 +3,7 @@
  */
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import * as Cause from "../../Cause.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"
@@ -19,7 +20,6 @@ import * as Schedule from "../../Schedule.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import { Stdio } from "../../Stdio.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
@@ -98,8 +98,8 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
   const spanPrefix = options.spanPrefix ?? "RpcServer"
   const concurrency = options.concurrency ?? "unbounded"
   const disableFatalDefects = options.disableFatalDefects ?? false
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Scope.Scope>()
-  const scope = ServiceMap.get(services, Scope.Scope)
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Scope.Scope>()
+  const scope = Context.get(services, Scope.Scope)
   const trackFiber = Fiber.runIn(Scope.forkUnsafe(scope, "parallel"))
   const concurrencySemaphore = concurrency === "unbounded"
     ? undefined
@@ -278,7 +278,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
       return close ? Effect.ensuring(write, close) : write
     })
     if (enableTracing) {
-      const parentSpan = requestFiber.services.mapUnsafe.get(
+      const parentSpan = requestFiber.context.mapUnsafe.get(
         Tracer.ParentSpan.key
       ) as Tracer.AnySpan | undefined
       effect = Effect.withSpan(effect, `${spanPrefix}.${request.tag}`, {
@@ -304,10 +304,10 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
     if (!isFork && concurrencySemaphore) {
       effect = concurrencySemaphore.withPermits(1)(effect)
     }
-    const serviceMap = new Map(entry.services.mapUnsafe)
-    requestFiber.services.mapUnsafe.forEach((value, key) => serviceMap.set(key, value))
-    serviceMap.set(Scope.Scope.key, scope)
-    const runFork = Effect.runForkWith(ServiceMap.makeUnsafe(serviceMap))
+    const context = new Map(entry.context.mapUnsafe)
+    requestFiber.context.mapUnsafe.forEach((value, key) => context.set(key, value))
+    context.set(Scope.Scope.key, scope)
+    const runFork = Effect.runForkWith(Context.makeUnsafe(context))
     const fiber = trackFiber(
       runFork(
         effect,
@@ -406,7 +406,7 @@ export const makeNoSerialization: <Rpcs extends Rpc.Any>(
 })
 
 const applyMiddleware = <A, E, R>(
-  services: ServiceMap.ServiceMap<never>,
+  context: Context.Context<never>,
   handler: Effect.Effect<A, E, R>,
   options: {
     readonly rpc: Rpc.AnyWithProps
@@ -417,7 +417,7 @@ const applyMiddleware = <A, E, R>(
   }
 ) => {
   for (const service of options.rpc.middlewares) {
-    const middleware = ServiceMap.getUnsafe(services, service)
+    const middleware = Context.getUnsafe(context, service)
     handler = middleware(handler as any, options) as any
   }
 
@@ -465,7 +465,7 @@ export const make: <Rpcs extends Rpc.Any>(
     supportsSpanPropagation,
     supportsTransferables
   } = yield* Protocol
-  const services = yield* Effect.services<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
+  const services = yield* Effect.context<Rpc.ToHandler<Rpcs> | Rpc.Middleware<Rpcs>>()
   const scope = yield* Scope.make()
 
   const server = yield* makeNoSerialization(group, {
@@ -484,7 +484,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeChunk(response.values), schemas.services),
+            Effect.provideContext(schemas.encodeChunk(response.values), schemas.context),
             (values) => ({ _tag: "Chunk", requestId: String(response.requestId), values })
           )
         }
@@ -497,7 +497,7 @@ export const make: <Rpcs extends Rpc.Any>(
             response.requestId,
             schemas.encodeDefect,
             schemas.collector,
-            Effect.provideServices(schemas.encodeExit(response.exit), schemas.services),
+            Effect.provideContext(schemas.encodeExit(response.exit), schemas.context),
             (exit) => ({ _tag: "Exit", requestId: String(response.requestId), exit })
           )
         }
@@ -533,7 +533,7 @@ export const make: <Rpcs extends Rpc.Any>(
     ) => Effect.Effect<NonEmptyReadonlyArray<unknown>, Schema.SchemaError>
     readonly encodeExit: (u: unknown) => Effect.Effect<ResponseExitEncoded["exit"], Schema.SchemaError>
     readonly encodeDefect: (u: unknown) => Effect.Effect<unknown, Schema.SchemaError>
-    readonly services: ServiceMap.ServiceMap<never>
+    readonly context: Context.Context<never>
     readonly collector?: Transferable.Collector["Service"] | undefined
   }
 
@@ -552,7 +552,7 @@ export const make: <Rpcs extends Rpc.Any>(
         ) as any,
         encodeExit: Schema.encodeUnknownEffect(Schema.toCodecJson(Rpc.exitSchema(rpc as any))) as any,
         encodeDefect: Schema.encodeUnknownEffect(Schema.toCodecJson(rpc.defectSchema)) as any,
-        services: entry.services
+        context: entry.context
       }
       schemasCache.set(rpc, schemas)
     }
@@ -648,7 +648,7 @@ export const make: <Rpcs extends Rpc.Any>(
         }
         const schemas = getSchemas(rpc as any)
         return Effect.matchEffect(
-          Effect.provideServices(schemas.decode(request.payload), schemas.services),
+          Effect.provideContext(schemas.decode(request.payload), schemas.context),
           {
             onFailure: (error) => sendRequestDefect(client, requestId, schemas.encodeDefect, error.issue.toString()),
             onSuccess: (payload) => {
@@ -761,7 +761,7 @@ export const layerHttp = <Rpcs extends Rpc.Any>(options: {
  * @since 4.0.0
  * @category protocol
  */
-export class Protocol extends ServiceMap.Service<
+export class Protocol extends Context.Service<
   Protocol,
   {
     readonly run: (
@@ -920,8 +920,8 @@ export const makeProtocolWithHttpEffect: Effect.Effect<
     Scope.Scope | HttpServerRequest.HttpServerRequest
   > = Effect.gen(function*() {
     const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest.HttpServerRequest)
-    const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest.HttpServerRequest)
+    const scope = Context.getUnsafe(fiber.context, Scope.Scope)
     const requestHeaders = Object.entries(request.headers)
     const data = yield* Effect.orDie<string | Uint8Array, any, never>(
       isBinary ? Effect.map(request.arrayBuffer, (buf) => new Uint8Array(buf)) : request.text

package/src/unstable/rpc/RpcWorker.ts

@@ -2,10 +2,10 @@
  * @since 4.0.0
  */
 import type { NoSuchElementError } from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Schema from "../../Schema.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Transferable from "../workers/Transferable.ts"
 import type { Protocol } from "./RpcServer.ts"
 
@@ -13,7 +13,7 @@ import type { Protocol } from "./RpcServer.ts"
  * @since 4.0.0
  * @category initial message
  */
-export class InitialMessage extends ServiceMap.Service<
+export class InitialMessage extends Context.Service<
   InitialMessage,
   Effect.Effect<
     readonly [
@@ -38,7 +38,7 @@ export declare namespace InitialMessage {
   }
 }
 
-const ProtocolTag: typeof Protocol = ServiceMap.Service("@effect/rpc/RpcServer/Protocol") as any
+const ProtocolTag: typeof Protocol = Context.Service("@effect/rpc/RpcServer/Protocol") as any
 
 /**
  * @since 4.0.0
@@ -71,9 +71,9 @@ export const layerInitialMessage = <S extends Schema.Top, R2>(
   build: Effect.Effect<S["Type"], never, R2>
 ): Layer.Layer<InitialMessage, never, S["EncodingServices"] | R2> =>
   Layer.effect(InitialMessage)(
-    Effect.servicesWith((services: ServiceMap.ServiceMap<S["EncodingServices"] | R2>) =>
+    Effect.contextWith((context: Context.Context<S["EncodingServices"] | R2>) =>
       Effect.succeed(
-        Effect.provideServices(Effect.orDie(makeInitialMessage(schema, build)), services)
+        Effect.provideContext(Effect.orDie(makeInitialMessage(schema, build)), context)
       )
     )
   )

package/src/unstable/rpc/Utils.ts

@@ -1,9 +1,9 @@
 /**
  * @since 4.0.0
  */
+import type * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Semaphore from "../../Semaphore.ts"
-import type * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 4.0.0
@@ -16,9 +16,9 @@ export const withRun = <
 <EX, RX>(f: (write: Parameters<A["run"]>[0]) => Effect.Effect<Omit<A, "run">, EX, RX>): Effect.Effect<A, EX, RX> =>
   Effect.suspend(() => {
     const semaphore = Semaphore.makeUnsafe(1)
-    let buffer: Array<[Array<any>, ServiceMap.ServiceMap<never>]> = []
+    let buffer: Array<[Array<any>, Context.Context<never>]> = []
     let write = (...args: Array<any>): Effect.Effect<void> =>
-      Effect.servicesWith((context) => {
+      Effect.contextWith((context) => {
         buffer.push([args, context])
         return Effect.void
       })
@@ -30,7 +30,7 @@ export const withRun = <
           write = f
 
           for (const [args, context] of buffer) {
-            yield* Effect.provideServices(Effect.suspend(() => f(...args)), context)
+            yield* Effect.provideContext(Effect.suspend(() => f(...args)), context)
           }
           buffer = []
 

package/src/unstable/socket/Socket.ts

@@ -4,6 +4,7 @@
 import type { NonEmptyReadonlyArray } from "../../Array.ts"
 import type * as Cause from "../../Cause.ts"
 import * as Channel from "../../Channel.ts"
+import * as Context from "../../Context.ts"
 import * as Deferred from "../../Deferred.ts"
 import type * as Duration from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
@@ -18,7 +19,6 @@ import * as Queue from "../../Queue.ts"
 import * as Result from "../../Result.ts"
 import * as Schema from "../../Schema.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 
 /**
  * @since 4.0.0
@@ -36,7 +36,7 @@ export const isSocket = (u: unknown): u is Socket => Predicate.hasProperty(u, Ty
  * @since 4.0.0
  * @category tags
  */
-export const Socket: ServiceMap.Service<Socket, Socket> = ServiceMap.Service<Socket>("effect/socket/Socket")
+export const Socket: Context.Service<Socket, Socket> = Context.Service<Socket>("effect/socket/Socket")
 
 /**
  * @since 4.0.0
@@ -398,7 +398,7 @@ export const defaultCloseCodeIsError = (_code: number) => true
  * @since 4.0.0
  * @category tags
  */
-export class WebSocket extends ServiceMap.Service<WebSocket, globalThis.WebSocket>()(
+export class WebSocket extends Context.Service<WebSocket, globalThis.WebSocket>()(
   "~effect/socket/Socket/WebSocket"
 ) {}
 
@@ -406,7 +406,7 @@ export class WebSocket extends ServiceMap.Service<WebSocket, globalThis.WebSocke
  * @since 4.0.0
  * @category tags
  */
-export class WebSocketConstructor extends ServiceMap.Service<
+export class WebSocketConstructor extends Context.Service<
   WebSocketConstructor,
   (url: string, protocols?: string | Array<string> | undefined) => globalThis.WebSocket
 >()("@effect/platform/Socket/WebSocketConstructor") {}
@@ -454,7 +454,7 @@ export const fromWebSocket = <RO>(
   Effect.withFiber((fiber) => {
     let currentWS: globalThis.WebSocket | undefined
     const latch = Latch.makeUnsafe(false)
-    const acquireContext = fiber.services as ServiceMap.ServiceMap<RO>
+    const acquireContext = fiber.context as Context.Context<RO>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
 
     const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
@@ -556,7 +556,7 @@ export const fromWebSocket = <RO>(
           () => Effect.void
         )
       })).pipe(
-        Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(acquireContext, input)),
+        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireContext, input)),
         Effect.ensuring(Effect.sync(() => {
           latch.closeUnsafe()
           currentWS = undefined
@@ -632,7 +632,7 @@ export const layerWebSocket: (
  * @since 4.0.0
  * @category fiber refs
  */
-export const SendQueueCapacity = ServiceMap.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
+export const SendQueueCapacity = Context.Reference<number>("~effect/socket/Socket/SendQueueCapacity", {
   defaultValue: () => 16
 })
 
@@ -658,7 +658,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
       readonly stream: InputTransformStream
       readonly fiberSet: FiberSet.FiberSet<any, any>
     } | undefined
-    const acquireServices = fiber.services as ServiceMap.ServiceMap<R>
+    const acquireServices = fiber.context as Context.Context<R>
     const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
     const runRaw = <_, E, R>(handler: (_: string | Uint8Array) => Effect.Effect<_, E, R> | void, opts?: {
       readonly onOpen?: Effect.Effect<void> | undefined
@@ -704,7 +704,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         )
       })).pipe(
         (_) => _,
-        Effect.updateServices((input: ServiceMap.ServiceMap<R>) => ServiceMap.merge(acquireServices, input)),
+        Effect.updateContext((input: Context.Context<R>) => Context.merge(acquireServices, input)),
         Effect.ensuring(Effect.sync(() => {
           latch.closeUnsafe()
           currentStream = undefined

package/src/unstable/socket/SocketServer.ts

@@ -1,16 +1,16 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Data from "../../Data.ts"
 import type * as Effect from "../../Effect.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Socket from "./Socket.ts"
 
 /**
  * @since 4.0.0
  * @category tags
  */
-export class SocketServer extends ServiceMap.Service<SocketServer, {
+export class SocketServer extends Context.Service<SocketServer, {
   readonly address: Address
   readonly run: <R, E, _>(
     handler: (socket: Socket.Socket) => Effect.Effect<_, E, R>

package/src/unstable/sql/SqlClient.ts

@@ -2,13 +2,13 @@
  * @since 4.0.0
  */
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Option from "../../Option.ts"
 import type * as Queue from "../../Queue.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Tracer from "../../Tracer.ts"
 import type { NoInfer } from "../../Types.ts"
@@ -69,7 +69,7 @@ export interface SqlClient extends Constructor {
  * @category models
  * @since 4.0.0
  */
-export const SqlClient = ServiceMap.Service<SqlClient>("effect/sql/SqlClient")
+export const SqlClient = Context.Service<SqlClient>("effect/sql/SqlClient")
 
 /**
  * @category models
@@ -180,7 +180,7 @@ export const make = Effect.fnUntraced(function*(options: SqlClient.MakeOptions)
  * @category transactions
  */
 export const makeWithTransaction = <I, S>(options: {
-  readonly transactionService: ServiceMap.Key<I, readonly [conn: S, counter: number]>
+  readonly transactionService: Context.Key<I, readonly [conn: S, counter: number]>
   readonly spanAttributes: ReadonlyArray<readonly [string, unknown]>
   readonly acquireConnection: Effect.Effect<readonly [Scope.Closeable | undefined, S], SqlError>
   readonly begin: (conn: NoInfer<S>) => Effect.Effect<void, SqlError>
@@ -199,9 +199,9 @@ export const makeWithTransaction = <I, S>(options: {
           for (const [key, value] of options.spanAttributes) {
             span.attribute(key, value)
           }
-          const services = fiber.services
+          const services = fiber.context
           const clock = fiber.getRef(Clock)
-          const connOption = ServiceMap.getOption(services, options.transactionService)
+          const connOption = Context.getOption(services, options.transactionService)
           const conn = connOption._tag === "Some"
             ? Effect.succeed([undefined, connOption.value[0]] as const)
             : options.acquireConnection
@@ -213,12 +213,12 @@ export const makeWithTransaction = <I, S>(options: {
             ) =>
               (id === 0 ? options.begin(conn) : options.savepoint(conn, id)).pipe(
                 Effect.flatMap(() =>
-                  Effect.provideServices(
+                  Effect.provideContext(
                     restore(effect),
-                    ServiceMap.mutate(services, (services) =>
+                    Context.mutate(services, (services) =>
                       services.pipe(
-                        ServiceMap.add(options.transactionService, [conn, id]),
-                        ServiceMap.add(Tracer.ParentSpan, span)
+                        Context.add(options.transactionService, [conn, id]),
+                        Context.add(Tracer.ParentSpan, span)
                       ))
                   )
                 ),
@@ -254,7 +254,7 @@ export const makeWithTransaction = <I, S>(options: {
  * @since 4.0.0
  */
 export class TransactionConnection
-  extends ServiceMap.Service<TransactionConnection, readonly [conn: Connection.Connection, depth: number]>()(
+  extends Context.Service<TransactionConnection, readonly [conn: Connection.Connection, depth: number]>()(
     "effect/sql/SqlClient/TransactionConnection"
   )
 {}
@@ -262,6 +262,6 @@ export class TransactionConnection
 /**
  * @since 4.0.0
  */
-export const SafeIntegers = ServiceMap.Reference<boolean>("effect/sql/SqlClient/SafeIntegers", {
+export const SafeIntegers = Context.Reference<boolean>("effect/sql/SqlClient/SafeIntegers", {
   defaultValue: () => false
 })

package/src/unstable/sql/SqlConnection.ts

@@ -1,9 +1,9 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import type { Effect } from "../../Effect.ts"
 import type { Scope } from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type { Stream } from "../../Stream.ts"
 import type { SqlError } from "./SqlError.ts"
 
@@ -55,7 +55,7 @@ export type Acquirer = Effect<Connection, SqlError, Scope>
  * @category tag
  * @since 4.0.0
  */
-export const Connection = ServiceMap.Service<Connection>("effect/sql/SqlConnection")
+export const Connection = Context.Service<Connection>("effect/sql/SqlConnection")
 
 /**
  * @category model