effect 4.0.0-beta.43 → 4.0.0-beta.45

package/src/unstable/schema/Model.ts

@@ -581,7 +581,7 @@ export interface JsonFromString<S extends Schema.Top> extends
 export const JsonFromString = <S extends Schema.Top>(
   schema: S
 ): JsonFromString<S> => {
-  const parsed = Schema.fromJsonString(schema)
+  const parsed = Schema.fromJsonString(Schema.toCodecJson(schema)) as any
   return Field({
     select: parsed,
     insert: parsed,
@@ -599,7 +599,7 @@ export const JsonFromString = <S extends Schema.Top>(
 export interface UuidV4Insert<B extends string> extends
   VariantSchema.Field<{
     readonly select: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
-    readonly insert: VariantSchema.Overrideable<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>>
+    readonly insert: Schema.withConstructorDefault<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>>
     readonly update: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
     readonly json: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
   }>
@@ -619,10 +619,8 @@ export const Uint8Array: Schema.instanceOf<Uint8Array<ArrayBuffer>> = Schema.Uin
  */
 export const UuidV4WithGenerate = <B extends string>(
   schema: Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>
-): VariantSchema.Overrideable<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>> =>
-  VariantSchema.Overrideable(schema, {
-    defaultValue: Effect.sync(() => Uuid.v4({}, new globalThis.Uint8Array(16)))
-  })
+): Schema.withConstructorDefault<Schema.brand<Schema.instanceOf<Uint8Array<ArrayBuffer>>, B>> =>
+  schema.pipe(Schema.withConstructorDefault(Effect.sync(() => Uuid.v4({}, new globalThis.Uint8Array(16)))))
 
 /**
  * A field that represents a binary UUID v4 that is generated on inserts.

package/src/unstable/schema/VariantSchema.ts

@@ -4,13 +4,10 @@
 import type { Brand } from "../../Brand.ts"
 import * as Effect from "../../Effect.ts"
 import { dual } from "../../Function.ts"
-import * as Option from "../../Option.ts"
 import { type Pipeable, pipeArguments } from "../../Pipeable.ts"
 import * as Predicate from "../../Predicate.ts"
 import * as Schema from "../../Schema.ts"
 import type * as AST from "../../SchemaAST.ts"
-import * as Getter from "../../SchemaGetter.ts"
-import * as Transformation from "../../SchemaTransformation.ts"
 import * as Struct_ from "../../Struct.ts"
 
 /**
@@ -470,7 +467,7 @@ export const Override = <A>(value: A): A & Brand<"Override"> => value as any
  */
 export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDefault> extends
   Schema.Bottom<
-    (S["Type"] & Brand<"Override">) | undefined,
+    S["Type"] & Brand<"Override">,
     S["Encoded"],
     S["DecodingServices"],
     S["EncodingServices"],
@@ -481,7 +478,7 @@ export interface Overrideable<S extends Schema.Top & Schema.WithoutConstructorDe
     S["~type.parameters"],
     (S["Type"] & Brand<"Override">) | undefined,
     S["~type.mutability"],
-    "optional",
+    "required",
     "with-default",
     S["~encoded.mutability"],
     S["~encoded.optionality"]
@@ -499,18 +496,8 @@ export const Overrideable = <S extends Schema.Top & Schema.WithoutConstructorDef
   }
 ): Overrideable<S> =>
   schema.pipe(
-    Schema.decodeTo(
-      Schema.optional(Schema.brand("Override")(Schema.toType(schema))),
-      Transformation.make({
-        decode: Getter.passthrough(),
-        encode: new Getter.Getter((o) => {
-          if (Option.isSome(o) && o.value !== undefined) {
-            return Effect.succeed(o)
-          }
-          return Effect.asSome(options.defaultValue)
-        })
-      })
-    )
+    Schema.decodeTo(Schema.brand("Override")(Schema.toType(schema))),
+    Schema.withConstructorDefault(Effect.map(options.defaultValue, Override))
   ) as any
 
 const StructProto = {

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

package/src/unstable/sql/SqlModel.ts

@@ -3,15 +3,13 @@
  * @category models
  */
 import type * as Cause from "../../Cause.ts"
-import type { Input } from "../../Duration.ts"
 import * as Effect from "../../Effect.ts"
-import { identity } from "../../Function.ts"
 import * as RequestResolver from "../../RequestResolver.ts"
 import type * as Schema from "../../Schema.ts"
 import type { Scope } from "../../Scope.ts"
 import type * as Model from "../schema/Model.ts"
 import { SqlClient } from "./SqlClient.ts"
-import type { SqlError } from "./SqlError.ts"
+import type { ResultLengthMismatch, SqlError } from "./SqlError.ts"
 import * as SqlResolver from "./SqlResolver.ts"
 import * as SqlSchema from "./SqlSchema.ts"
 
@@ -201,7 +199,7 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = ${request[idCol
  * @since 4.0.0
  * @category repository
  */
-export const makeDataLoaders = <
+export const makeResolvers = <
   S extends Model.Any,
   Id extends (keyof S["Type"]) & (keyof S["update"]["Type"]) & (keyof S["fields"])
 >(
@@ -210,31 +208,36 @@ export const makeDataLoaders = <
     readonly tableName: string
     readonly spanPrefix: string
     readonly idColumn: Id
-    readonly window: Input
-    readonly maxBatchSize?: number | undefined
   }
 ): Effect.Effect<
   {
-    readonly insert: (
-      insert: S["insert"]["Type"]
-    ) => Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["insert"]["EncodingServices"]
+    readonly insert: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["insert"]["Type"],
+        S["Type"],
+        ResultLengthMismatch | SqlError,
+        S["insert"]["EncodingServices"]
+      >
     >
-    readonly insertVoid: (
-      insert: S["insert"]["Type"]
-    ) => Effect.Effect<void, SqlError | Schema.SchemaError, S["insert"]["EncodingServices"]>
-    readonly findById: (
-      id: S["fields"][Id]["Type"]
-    ) => Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError | Cause.NoSuchElementError,
-      S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+    readonly insertVoid: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<S["insert"]["Type"], void, SqlError, S["insert"]["EncodingServices"]>
+    >
+    readonly findById: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        S["Type"],
+        Cause.NoSuchElementError | SqlError,
+        S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+      >
+    >
+    readonly delete: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        void,
+        SqlError,
+        S["fields"][Id]["EncodingServices"]
+      >
     >
-    readonly delete: (
-      id: S["fields"][Id]["Type"]
-    ) => Effect.Effect<void, SqlError | Schema.SchemaError, S["fields"][Id]["EncodingServices"]>
   },
   never,
   SqlClient | Scope
@@ -243,9 +246,15 @@ export const makeDataLoaders = <
     const sql = yield* SqlClient
     const idSchema = Model.fields[options.idColumn] as Schema.Top
     const idColumn = options.idColumn as string
-    const setMaxBatchSize = options.maxBatchSize ? RequestResolver.batchN(options.maxBatchSize) : identity
 
-    const insertResolver = SqlResolver.ordered({
+    const insert: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["insert"]["Type"],
+        S["Type"],
+        ResultLengthMismatch | SqlError,
+        S["DecodingServices"] | S["insert"]["EncodingServices"]
+      >
+    > = SqlResolver.ordered({
       Request: Model.insert,
       Result: Model,
       execute: (request: any) =>
@@ -259,44 +268,26 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
           orElse: () => sql`insert into ${sql(options.tableName)} ${sql.insert(request).returning("*")}`
         })
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.insertResolver`)
     )
-    const insertExecute = SqlResolver.request(insertResolver)
-    const insert = (
-      insert: S["insert"]["Type"]
-    ): Effect.Effect<
-      S["Type"],
-      SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["insert"]["EncodingServices"]
-    > =>
-      insertExecute(insert).pipe(
-        Effect.catchTag("ResultLengthMismatch", Effect.die),
-        Effect.withSpan(`${options.spanPrefix}.insert`, {}, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const insertVoidResolver = SqlResolver.void({
+    const insertVoid: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<S["insert"]["Type"], void, Schema.SchemaError | SqlError, S["insert"]["EncodingServices"]>
+    > = SqlResolver.void({
       Request: Model.insert,
       execute: (request: any) => sql`insert into ${sql(options.tableName)} ${sql.insert(request)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.insertVoidResolver`)
     )
-    const insertVoidExecute = SqlResolver.request(insertVoidResolver)
-    const insertVoid = (
-      insert: S["insert"]["Type"]
-    ): Effect.Effect<void, SqlError | Schema.SchemaError, S["insert"]["EncodingServices"]> =>
-      insertVoidExecute(insert).pipe(
-        Effect.withSpan(`${options.spanPrefix}.insertVoid`, {}, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const findByIdResolver = SqlResolver.findById({
+    const findById: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        S["Type"],
+        Cause.NoSuchElementError | Schema.SchemaError | SqlError,
+        S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
+      >
+    > = SqlResolver.findById({
       Id: idSchema,
       Result: Model,
       ResultId(request: any) {
@@ -304,41 +295,22 @@ select * from ${sql(options.tableName)} where ${sql(idColumn)} = LAST_INSERT_ID(
       },
       execute: (ids: any) => sql`select * from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.findByIdResolver`)
     )
-    const findByIdExecute = SqlResolver.request(findByIdResolver)
-    const findById = (
-      id: S["fields"][Id]["Type"]
-    ): Effect.Effect<
-      S["Type"],
-      Cause.NoSuchElementError | SqlError | Schema.SchemaError,
-      S["DecodingServices"] | S["fields"][Id]["EncodingServices"]
-    > =>
-      findByIdExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.findById`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
-      ) as any
 
-    const deleteResolver = SqlResolver.void({
+    const delete_: RequestResolver.RequestResolver<
+      SqlResolver.SqlRequest<
+        S["fields"][Id]["Type"],
+        void,
+        Schema.SchemaError | SqlError,
+        S["fields"][Id]["EncodingServices"]
+      >
+    > = SqlResolver.void({
       Request: idSchema,
       execute: (ids: any) => sql`delete from ${sql(options.tableName)} where ${sql.in(idColumn, ids)}`
     }).pipe(
-      RequestResolver.setDelay(options.window),
-      setMaxBatchSize,
       RequestResolver.withSpan(`${options.spanPrefix}.deleteResolver`)
     )
-    const deleteExecute = SqlResolver.request(deleteResolver)
-    const delete_ = (
-      id: S["fields"][Id]["Type"]
-    ): Effect.Effect<void, SqlError | Schema.SchemaError, S["fields"][Id]["EncodingServices"]> =>
-      deleteExecute(id).pipe(
-        Effect.withSpan(`${options.spanPrefix}.delete`, { attributes: { id } }, {
-          captureStackTrace: false
-        })
-      ) as any
 
     return { insert, insertVoid, findById, delete: delete_ } as const
   })

package/src/unstable/sql/SqlResolver.ts

@@ -108,13 +108,13 @@ export const ordered = <Req extends Schema.Top, Res extends Schema.Top, _, E, R>
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       if (results.length !== inputs.length) {
         return yield* new ResultLengthMismatch({ expected: inputs.length, actual: results.length })
       }
       const decodedResults = yield* decodeArray(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
         entries[i].completeUnsafe(Exit.succeed(decodedResults[i]))
@@ -165,10 +165,10 @@ export const grouped = <Req extends Schema.Top, Res extends Schema.Top, K, Row,
       const inputs = yield* partitionRequests(entries, options.Request)
       const resultMap = MutableHashMap.empty<K, Arr.NonEmptyArray<Res["Type"]>>()
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0, len = decodedResults.length; i < len; i++) {
         const result = decodedResults[i]
@@ -227,17 +227,17 @@ export const findById = <Id extends Schema.Top, Res extends Schema.Top, Row, E,
     SqlClient.TransactionConnection["Service"] | undefined
   >({
     key(entry) {
-      const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+      const conn = entry.context.mapUnsafe.get(SqlClient.TransactionConnection.key)
       if (!conn) return undefined
       return Equal.byReferenceUnsafe(conn)
     },
     resolver: Effect.fnUntraced(function*(entries) {
       const [inputs, idMap] = yield* partitionRequestsById(entries, options.Id)
       const results = yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       const decodedResults = yield* decodeResults(results).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < decodedResults.length; i++) {
         const result = decodedResults[i]
@@ -287,7 +287,7 @@ const void_ = <Req extends Schema.Top, _, E, R>(
     resolver: Effect.fnUntraced(function*(entries) {
       const inputs = yield* partitionRequests(entries, options.Request)
       yield* options.execute(inputs as any).pipe(
-        Effect.provideServices(entries[0].services)
+        Effect.provideContext(entries[0].context)
       )
       for (let i = 0; i < entries.length; i++) {
         entries[i].completeUnsafe(Exit.void)
@@ -326,7 +326,7 @@ const partitionRequests = function*<In, A, E, R, InE>(
 
   for (let i = 0; i < len; i++) {
     entry = requests[i]
-    yield (Effect.provideServices(handle(encode(entry.request.payload)), entry.services) as Effect.Effect<void>)
+    yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
   }
 
   return inputs
@@ -352,7 +352,7 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 
   for (let i = 0; i < len; i++) {
     entry = requests[i]
-    yield (Effect.provideServices(handle(encode(entry.request.payload)), entry.services) as Effect.Effect<void>)
+    yield (Effect.provideContext(handle(encode(entry.request.payload)), entry.context) as Effect.Effect<void>)
     MutableHashMap.set(byIdMap, entry.request.payload, entry)
   }
 
@@ -360,7 +360,7 @@ const partitionRequestsById = function*<In, A, E, R, InE>(
 }
 
 function transactionKey<A>(entry: Request.Entry<A>): SqlClient.TransactionConnection["Service"] | undefined {
-  const conn = entry.services.mapUnsafe.get(SqlClient.TransactionConnection.key)
+  const conn = entry.context.mapUnsafe.get(SqlClient.TransactionConnection.key)
   if (!conn) return undefined
   return Equal.byReferenceUnsafe(conn)
 }

package/src/unstable/sql/Statement.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import { Clock } from "../../Clock.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as Fiber from "../../Fiber.ts"
 import { constUndefined } from "../../Function.ts"
@@ -11,7 +12,6 @@ import * as internalEffect from "../../internal/effect.ts"
 import type { Pipeable } from "../../Pipeable.ts"
 import { hasProperty } from "../../Predicate.ts"
 import { TracerTimingEnabled } from "../../References.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import type * as Tracer from "../../Tracer.ts"
 import type { Acquirer, Connection, Row } from "./SqlConnection.ts"
@@ -76,7 +76,7 @@ export type Transformer = (
  * @category transformer
  * @since 4.0.0
  */
-export const CurrentTransformer = ServiceMap.Reference<Transformer | undefined>("effect/sql/CurrentTransformer", {
+export const CurrentTransformer = Context.Reference<Transformer | undefined>("effect/sql/CurrentTransformer", {
   defaultValue: constUndefined
 })