effect 4.0.0-beta.42 → 4.0.0-beta.44

package/src/unstable/http/HttpEffect.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import type * as Cause from "../../Cause.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as Exit from "../../Exit.ts"
 import * as Fiber from "../../Fiber.ts"
@@ -9,7 +10,6 @@ import { dual } from "../../Function.ts"
 import { reportCauseUnsafe } from "../../internal/effect.ts"
 import * as Layer from "../../Layer.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as HttpBody from "./HttpBody.ts"
 import { type HttpMiddleware, tracer } from "./HttpMiddleware.ts"
@@ -36,7 +36,7 @@ export const toHandled = <E, R, EH, RH>(
     Effect.flatMapEager(causeResponse(cause), ([response, cause]) => {
       const fiber = Fiber.getCurrent()!
       reportCauseUnsafe(fiber, cause)
-      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
       const handler = requestPreResponseHandlers.get(request.source)
       const cont = cause.reasons.length === 0 ? Effect.succeed(response) : Effect.failCause(cause)
       if (handler === undefined) {
@@ -59,7 +59,7 @@ export const toHandled = <E, R, EH, RH>(
   const responded = Effect.matchCauseEffect(self, {
     onSuccess: (response) => {
       const fiber = Fiber.getCurrent()!
-      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
       const handler = requestPreResponseHandlers.get(request.source)
       if (handler === undefined) {
         ;(request as any)[handledSymbol] = true
@@ -83,7 +83,7 @@ export const toHandled = <E, R, EH, RH>(
       onFailure(cause): Effect.Effect<void, EH, RH> {
         const fiber = Fiber.getCurrent()!
         reportCauseUnsafe(fiber, cause)
-        const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+        const request = Context.getUnsafe(fiber.context, HttpServerRequest)
         if (handledSymbol in request) return Effect.void
         return Effect.matchCauseEffectEager(causeResponse(cause), {
           onFailure(_) {
@@ -96,7 +96,7 @@ export const toHandled = <E, R, EH, RH>(
       },
       onSuccess(response): Effect.Effect<void, EH, RH> {
         const fiber = Fiber.getCurrent()!
-        const request = ServiceMap.getUnsafe(fiber.services, Request.HttpServerRequest)
+        const request = Context.getUnsafe(fiber.context, Request.HttpServerRequest)
         return handledSymbol in request ? Effect.void : handleResponse(request, response)
       }
     })
@@ -128,7 +128,7 @@ export const scopeTransferToStream = (
     return response
   }
   const fiber = Fiber.getCurrent()!
-  const scope = ServiceMap.getUnsafe(fiber.services, Scope.Scope) as Scope.Closeable
+  const scope = Context.getUnsafe(fiber.context, Scope.Scope) as Scope.Closeable
   scopeDisableClose(scope)
   return Response.setBody(
     response,
@@ -145,10 +145,10 @@ const scopeEjected = Symbol.for("effect/http/HttpEffect/scopeEjected")
 const scoped = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
   Effect.withFiber((fiber) => {
     const scope = Scope.makeUnsafe()
-    const prevServices = fiber.services
-    fiber.setServices(ServiceMap.add(fiber.services, Scope.Scope, scope))
+    const prevServices = fiber.context
+    fiber.setContext(Context.add(fiber.context, Scope.Scope, scope))
     return Effect.onExitPrimitive(effect, (exit) => {
-      fiber.setServices(prevServices)
+      fiber.setContext(prevServices)
       if (scopeEjected in scope) return undefined
       return Scope.closeUnsafe(scope, exit)
     }, true)
@@ -218,35 +218,35 @@ export const withPreResponseHandler: {
  * @category conversions
  */
 export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided | Scope.Scope | HttpServerRequest>>(
-  services: ServiceMap.ServiceMap<Provided>
+  context: Context.Context<Provided>
 ) =>
 <E>(
   self: Effect.Effect<HttpServerResponse, E, R>,
   middleware?: HttpMiddleware | undefined
 ): [ReqR] extends [never] ?
-  (request: Request, services?: ServiceMap.ServiceMap<never> | undefined) => Promise<globalThis.Response>
-  : (request: Request, services: ServiceMap.ServiceMap<ReqR>) => Promise<globalThis.Response> =>
+  (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response>
+  : (request: Request, context: Context.Context<ReqR>) => Promise<globalThis.Response> =>
 {
   const resolveSymbol = Symbol.for("@effect/platform/HttpApp/resolve")
   const httpApp = toHandled(self, (request, response) => {
     response = scopeTransferToStream(response)
     ;(request as any)[resolveSymbol](
-      Response.toWeb(response, { withoutBody: request.method === "HEAD", services })
+      Response.toWeb(response, { withoutBody: request.method === "HEAD", context })
     )
     return Effect.void
   }, middleware)
-  return (request: Request, reqServices?: ServiceMap.ServiceMap<never> | undefined): Promise<globalThis.Response> =>
+  return (request: Request, reqContext?: Context.Context<never> | undefined): Promise<globalThis.Response> =>
     new Promise((resolve) => {
-      const contextMap = new Map<string, any>(services.mapUnsafe)
-      if (ServiceMap.isServiceMap(reqServices)) {
-        for (const [key, value] of reqServices.mapUnsafe) {
+      const contextMap = new Map<string, any>(context.mapUnsafe)
+      if (Context.isContext(reqContext)) {
+        for (const [key, value] of reqContext.mapUnsafe) {
           contextMap.set(key, value)
         }
       }
       const httpServerRequest = Request.fromWeb(request)
       contextMap.set(HttpServerRequest.key, httpServerRequest)
       ;(httpServerRequest as any)[resolveSymbol] = resolve
-      const fiber = Effect.runForkWith(ServiceMap.makeUnsafe(contextMap))(httpApp as any)
+      const fiber = Effect.runForkWith(Context.makeUnsafe(contextMap))(httpApp as any)
       request.signal?.addEventListener("abort", () => {
         fiber.interruptUnsafe(undefined, ClientAbort.annotation)
       }, { once: true })
@@ -260,8 +260,8 @@ export const toWebHandlerWith = <Provided, R = never, ReqR = Exclude<R, Provided
 export const toWebHandler: <E>(
   self: Effect.Effect<HttpServerResponse, E, HttpServerRequest | Scope.Scope>,
   middleware?: HttpMiddleware | undefined
-) => (request: Request, services?: ServiceMap.ServiceMap<never> | undefined) => Promise<globalThis.Response> =
-  toWebHandlerWith(ServiceMap.empty())
+) => (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response> =
+  toWebHandlerWith(Context.empty())
 
 /**
  * @since 4.0.0
@@ -277,7 +277,7 @@ export const toWebHandlerLayerWith = <
   layer: Layer.Layer<Provided, LE>,
   options: {
     readonly toHandler: (
-      services: ServiceMap.ServiceMap<Provided>
+      context: Context.Context<Provided>
     ) => Effect.Effect<Effect.Effect<HttpServerResponse, E, R>, LE>
     readonly middleware?: HttpMiddleware | undefined
     readonly memoMap?: Layer.MemoMap | undefined
@@ -286,39 +286,39 @@ export const toWebHandlerLayerWith = <
   readonly dispose: () => Promise<void>
   readonly handler: [ReqR] extends [never] ? (
       request: Request,
-      services?: ServiceMap.ServiceMap<never> | undefined
+      context?: Context.Context<never> | undefined
     ) => Promise<globalThis.Response>
     : (
       request: Request,
-      services: ServiceMap.ServiceMap<ReqR>
+      context: Context.Context<ReqR>
     ) => Promise<globalThis.Response>
 } => {
   const scope = Scope.makeUnsafe()
   const dispose = () => Effect.runPromise(Scope.close(scope, Exit.void))
 
   let handlerCache:
-    | ((request: Request, services?: ServiceMap.ServiceMap<ReqR> | undefined) => Promise<globalThis.Response>)
+    | ((request: Request, context?: Context.Context<ReqR> | undefined) => Promise<globalThis.Response>)
     | undefined
   let handlerPromise:
-    | Promise<(request: Request, services?: ServiceMap.ServiceMap<ReqR> | undefined) => Promise<globalThis.Response>>
+    | Promise<(request: Request, context?: Context.Context<ReqR> | undefined) => Promise<globalThis.Response>>
     | undefined
   function handler(
     request: Request,
-    services?: ServiceMap.ServiceMap<ReqR> | undefined
+    context?: Context.Context<ReqR> | undefined
   ): Promise<globalThis.Response> {
     if (handlerCache) {
-      return handlerCache(request, services)
+      return handlerCache(request, context)
     }
     handlerPromise ??= Effect.runPromise(Effect.gen(function*() {
-      const services = yield* (options.memoMap
+      const context = yield* (options.memoMap
         ? Layer.buildWithMemoMap(layer, options.memoMap, scope)
         : Layer.buildWithScope(layer, scope))
-      return handlerCache = toWebHandlerWith<Provided, R>(services)(
-        yield* options.toHandler(services),
+      return handlerCache = toWebHandlerWith<Provided, R>(context)(
+        yield* options.toHandler(context),
         options.middleware
       ) as any
     }))
-    return handlerPromise.then((f) => f(request, services))
+    return handlerPromise.then((f) => f(request, context))
   }
   return { dispose, handler: handler as any } as const
 }
@@ -337,10 +337,10 @@ export const toWebHandlerLayer = <E, R, Provided, LE, ReqR = Exclude<R, Provided
 ): {
   readonly dispose: () => Promise<void>
   readonly handler: [ReqR] extends [never]
-    ? (request: Request, services?: ServiceMap.ServiceMap<never> | undefined) => Promise<globalThis.Response>
+    ? (request: Request, context?: Context.Context<never> | undefined) => Promise<globalThis.Response>
     : (
       request: Request,
-      services: ServiceMap.ServiceMap<ReqR>
+      context: Context.Context<ReqR>
     ) => Promise<globalThis.Response>
 } =>
   toWebHandlerLayerWith(layer, {
@@ -357,10 +357,10 @@ export const fromWebHandler = (
 ): Effect.Effect<HttpServerResponse, HttpServerError, HttpServerRequest> =>
   Effect.callback((resume, signal) => {
     const fiber = Fiber.getCurrent()!
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest)
     const requestResult = Request.toWebResult(request, {
       signal,
-      services: fiber.services
+      context: fiber.context
     })
     if (requestResult._tag === "Failure") {
       return resume(Effect.fail(new HttpServerError({ reason: requestResult.failure })))

package/src/unstable/http/HttpIncomingMessage.ts

@@ -1,6 +1,7 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import type * as FileSystem from "../../FileSystem.ts"
 import type * as Inspectable from "../../Inspectable.ts"
@@ -9,7 +10,6 @@ import { hasProperty } from "../../Predicate.ts"
 import { redact } from "../../Redactable.ts"
 import * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import type * as Stream from "../../Stream.ts"
 import type * as Headers from "./Headers.ts"
 import * as UrlParams from "./UrlParams.ts"
@@ -90,7 +90,7 @@ export const schemaHeaders = <A, I extends Readonly<Record<string, string | unde
  * @since 4.0.0
  * @category References
  */
-export const MaxBodySize = ServiceMap.Reference<FileSystem.Size | undefined>(
+export const MaxBodySize = Context.Reference<FileSystem.Size | undefined>(
   "effect/http/HttpIncomingMessage/MaxBodySize",
   { defaultValue: () => undefined }
 )

package/src/unstable/http/HttpMiddleware.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 { constant, constFalse } from "../../Function.ts"
 import * as internalEffect from "../../internal/effect.ts"
@@ -10,7 +11,6 @@ import * as Option from "../../Option.ts"
 import type { Predicate } from "../../Predicate.ts"
 import type { ReadonlyRecord } from "../../Record.ts"
 import { TracerEnabled } from "../../References.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import { ParentSpan } from "../../Tracer.ts"
 import * as Headers from "./Headers.ts"
 import { causeResponseStripped, exitResponse } from "./HttpServerError.ts"
@@ -49,13 +49,26 @@ export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
 const loggerDisabledRequests = new WeakSet<object>()
 
+const stripSearchAndHash = (url: string): string => {
+  const queryIndex = url.indexOf("?")
+  const hashIndex = url.indexOf("#")
+
+  if (queryIndex === -1) {
+    return hashIndex === -1 ? url : url.slice(0, hashIndex)
+  }
+  if (hashIndex === -1) {
+    return url.slice(0, queryIndex)
+  }
+  return url.slice(0, Math.min(queryIndex, hashIndex))
+}
+
 /**
  * @since 4.0.0
  * @category Logger
  */
 export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
   Effect.withFiber((fiber) => {
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest)
     loggerDisabledRequests.add(request.source)
     return self
   })
@@ -64,7 +77,7 @@ export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effec
  * @since 4.0.0
  * @category Tracer
  */
-export const TracerDisabledWhen = ServiceMap.Reference<Predicate<HttpServerRequest>>(
+export const TracerDisabledWhen = Context.Reference<Predicate<HttpServerRequest>>(
   "effect/http/HttpMiddleware/TracerDisabledWhen",
   { defaultValue: () => constFalse }
 )
@@ -81,7 +94,7 @@ export const layerTracerDisabledForUrls = (
  * @since 4.0.0
  * @category Tracer
  */
-export const SpanNameGenerator = ServiceMap.Reference<(request: HttpServerRequest) => string>(
+export const SpanNameGenerator = Context.Reference<(request: HttpServerRequest) => string>(
   "@effect/platform/HttpMiddleware/SpanNameGenerator",
   { defaultValue: () => (request) => `http.server ${request.method}` }
 )
@@ -95,7 +108,8 @@ export const logger: <E, R>(
 ) => Effect.Effect<HttpServerResponse, E, HttpServerRequest | R> = make((httpApp) => {
   let counter = 0
   return Effect.withFiber((fiber) => {
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest)
+    const path = stripSearchAndHash(request.url)
     return Effect.withLogSpan(
       Effect.flatMap(Effect.exit(httpApp), (exit) => {
         if (loggerDisabledRequests.has(request.source)) {
@@ -105,7 +119,7 @@ export const logger: <E, R>(
           return Effect.andThen(
             Effect.annotateLogs(Effect.log(Option.getOrElse(cause, () => "Sent HTTP Response")), {
               "http.method": request.method,
-              "http.url": request.url,
+              "http.url": path,
               "http.status": response.status
             }),
             exit
@@ -114,7 +128,7 @@ export const logger: <E, R>(
         return Effect.andThen(
           Effect.annotateLogs(Effect.log("Sent HTTP response"), {
             "http.method": request.method,
-            "http.url": request.url,
+            "http.url": path,
             "http.status": exit.value.status
           }),
           exit
@@ -133,7 +147,7 @@ export const tracer: <E, R>(
   httpApp: Effect.Effect<HttpServerResponse, E, HttpServerRequest | R>
 ) => Effect.Effect<HttpServerResponse, E, HttpServerRequest | R> = make((httpApp) =>
   Effect.withFiber((fiber) => {
-    const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest)
     const disabled = !fiber.getRef(TracerEnabled) || fiber.getRef(TracerDisabledWhen)(request)
     if (disabled) {
       return httpApp
@@ -143,10 +157,10 @@ export const tracer: <E, R>(
       parent: Option.getOrUndefined(TraceContext.fromHeaders(request.headers)),
       kind: "server"
     })
-    const prevServices = fiber.services
-    fiber.setServices(ServiceMap.add(fiber.services, ParentSpan, span))
+    const prevServices = fiber.context
+    fiber.setContext(Context.add(fiber.context, ParentSpan, span))
     return Effect.onExitPrimitive(httpApp, (exit) => {
-      fiber.setServices(prevServices)
+      fiber.setContext(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
       fiber.currentDispatcher.scheduleTask(() => {
         const url = Request.toURL(request)
@@ -214,8 +228,8 @@ export const searchParamsParser = <E, R>(
   httpApp: Effect.Effect<HttpServerResponse, E, R>
 ): Effect.Effect<Response.HttpServerResponse, E, HttpServerRequest | Exclude<R, Request.ParsedSearchParams>> =>
   Effect.withFiber((fiber) => {
-    const services = fiber.services
-    const request = ServiceMap.getUnsafe(services, HttpServerRequest)
+    const services = fiber.context
+    const request = Context.getUnsafe(services, HttpServerRequest)
     const params = Request.searchParamsFromURL(new URL(request.originalUrl))
     return Effect.provideService(
       httpApp,
@@ -332,7 +346,7 @@ export const cors = (options?: {
     httpApp: Effect.Effect<HttpServerResponse, E, R>
   ): Effect.Effect<HttpServerResponse, E, R | HttpServerRequest> =>
     Effect.withFiber((fiber) => {
-      const request = ServiceMap.getUnsafe(fiber.services, HttpServerRequest)
+      const request = Context.getUnsafe(fiber.context, HttpServerRequest)
       if (request.method === "OPTIONS") {
         return Effect.succeed(Response.empty({
           status: 204,

package/src/unstable/http/HttpPlatform.ts

@@ -1,13 +1,13 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Option from "../../Option.ts"
 import type { PlatformError } from "../../PlatformError.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Stream from "../../Stream.ts"
 import * as Etag from "./Etag.ts"
 import * as Headers from "./Headers.ts"
@@ -18,7 +18,7 @@ import * as Response from "./HttpServerResponse.ts"
  * @since 4.0.0
  * @category tags
  */
-export class HttpPlatform extends ServiceMap.Service<HttpPlatform, {
+export class HttpPlatform extends Context.Service<HttpPlatform, {
   readonly fileResponse: (
     path: string,
     options?: Response.Options.WithContent & {

package/src/unstable/http/HttpRouter.ts

@@ -2,6 +2,7 @@
  * @since 4.0.0
  */
 import * as Arr from "../../Array.ts"
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import { compose, dual, identity } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
@@ -10,7 +11,6 @@ import type { ReadonlyRecord } from "../../Record.ts"
 import * as Schema from "../../Schema.ts"
 import type { ParseOptions } from "../../SchemaAST.ts"
 import * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Tracer from "../../Tracer.ts"
 import type * as Types from "../../Types.ts"
 import * as FindMyWay from "./FindMyWay.ts"
@@ -80,7 +80,7 @@ export interface HttpRouter {
  * @since 4.0.0
  * @category HttpRouter
  */
-export const HttpRouter: ServiceMap.Service<HttpRouter, HttpRouter> = ServiceMap.Service<HttpRouter>(
+export const HttpRouter: Context.Service<HttpRouter, HttpRouter> = Context.Service<HttpRouter>(
   "effect/http/HttpRouter"
 )
 
@@ -100,8 +100,8 @@ export const make = Effect.gen(function*() {
     | Request.From<"Requires", Exclude<Route.Context<Routes[number]>, Provided>>
     | Request.From<"Error", Route.Error<Routes[number]>>
   > =>
-    Effect.servicesWith((services: ServiceMap.ServiceMap<never>) => {
-      const middleware = getMiddleware(services)
+    Effect.contextWith((context: Context.Context<never>) => {
+      const middleware = getMiddleware(context)
       const applyMiddleware = (effect: Effect.Effect<HttpServerResponse.HttpServerResponse>) => {
         for (let i = 0; i < middleware.length; i++) {
           effect = middleware[i](effect)
@@ -163,7 +163,7 @@ export const make = Effect.gen(function*() {
       }),
     asHttpEffect() {
       let handler = Effect.withFiber<HttpServerResponse.HttpServerResponse, unknown>((fiber) => {
-        const contextMap = new Map(fiber.services.mapUnsafe)
+        const contextMap = new Map(fiber.context.mapUnsafe)
         const request = contextMap.get(HttpServerRequest.HttpServerRequest.key) as HttpServerRequest.HttpServerRequest
         let result = router.find(request.method, request.url)
         if (result === undefined && request.method === "HEAD") {
@@ -190,14 +190,14 @@ export const make = Effect.gen(function*() {
         if (span && span._tag === "Span") {
           span.attribute("http.route", route.path)
         }
-        return Effect.provideServices(
+        return Effect.provideContext(
           (route.uninterruptible ?
             route.handler :
             Effect.interruptible(route.handler)) as Effect.Effect<
               HttpServerResponse.HttpServerResponse,
               unknown
             >,
-          ServiceMap.makeUnsafe(contextMap)
+          Context.makeUnsafe(contextMap)
         )
       })
       if (middleware.size === 0) return handler
@@ -218,7 +218,7 @@ function sliceRequestUrl(request: HttpServerRequest.HttpServerRequest, prefix: s
  * @since 4.0.0
  * @category Configuration
  */
-export const RouterConfig = ServiceMap.Reference<Partial<FindMyWay.RouterConfig>>(
+export const RouterConfig = Context.Reference<Partial<FindMyWay.RouterConfig>>(
   "effect/http/HttpRouter/RouterConfig",
   { defaultValue: () => ({}) }
 )
@@ -227,7 +227,7 @@ export const RouterConfig = ServiceMap.Reference<Partial<FindMyWay.RouterConfig>
  * @since 4.0.0
  * @category RouteContext
  */
-export class RouteContext extends ServiceMap.Service<RouteContext, {
+export class RouteContext extends Context.Service<RouteContext, {
   readonly params: Readonly<Record<string, string | undefined>>
   readonly route: Route<unknown, unknown>
 }>()("effect/http/HttpRouter/RouteContext") {}
@@ -268,15 +268,15 @@ export const schemaJson = <
   HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams | RouteContext | RD
 > => {
   const parse = Schema.decodeUnknownEffect(schema)
-  return Effect.servicesWith(
+  return Effect.contextWith(
     (
-      services: ServiceMap.ServiceMap<
+      context: Context.Context<
         HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams | RouteContext
       >
     ) => {
-      const request = ServiceMap.get(services, HttpServerRequest.HttpServerRequest)
-      const searchParams = ServiceMap.get(services, HttpServerRequest.ParsedSearchParams)
-      const routeContext = ServiceMap.get(services, RouteContext)
+      const request = Context.get(context, HttpServerRequest.HttpServerRequest)
+      const searchParams = Context.get(context, HttpServerRequest.ParsedSearchParams)
+      const routeContext = Context.get(context, RouteContext)
       return Effect.flatMap(request.json, (body) =>
         parse({
           method: request.method,
@@ -316,15 +316,15 @@ export const schemaNoBody = <
   HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams | RouteContext | RD
 > => {
   const parse = Schema.decodeUnknownEffect(schema)
-  return Effect.servicesWith(
+  return Effect.contextWith(
     (
-      services: ServiceMap.ServiceMap<
+      context: Context.Context<
         HttpServerRequest.HttpServerRequest | HttpServerRequest.ParsedSearchParams | RouteContext
       >
     ) => {
-      const request = ServiceMap.get(services, HttpServerRequest.HttpServerRequest)
-      const searchParams = ServiceMap.get(services, HttpServerRequest.ParsedSearchParams)
-      const routeContext = ServiceMap.get(services, RouteContext)
+      const request = Context.get(context, HttpServerRequest.HttpServerRequest)
+      const searchParams = Context.get(context, HttpServerRequest.ParsedSearchParams)
+      const routeContext = Context.get(context, RouteContext)
       return parse({
         method: request.method,
         url: request.url,
@@ -346,9 +346,9 @@ export const schemaParams = <A, I extends Readonly<Record<string, string | Reado
   options?: ParseOptions | undefined
 ): Effect.Effect<A, Schema.SchemaError, HttpServerRequest.ParsedSearchParams | RouteContext | RD> => {
   const parse = Schema.decodeUnknownEffect(schema)
-  return Effect.servicesWith((services: ServiceMap.ServiceMap<HttpServerRequest.ParsedSearchParams | RouteContext>) => {
-    const searchParams = ServiceMap.get(services, HttpServerRequest.ParsedSearchParams)
-    const routeContext = ServiceMap.get(services, RouteContext)
+  return Effect.contextWith((context: Context.Context<HttpServerRequest.ParsedSearchParams | RouteContext>) => {
+    const searchParams = Context.get(context, HttpServerRequest.ParsedSearchParams)
+    const routeContext = Context.get(context, RouteContext)
     return parse({ ...searchParams, ...routeContext.params }, options)
   })
 }
@@ -484,7 +484,7 @@ export const toHttpEffect = <A, E, R>(
 > =>
   Effect.gen(function*() {
     const context = yield* Layer.build(Layer.provideMerge(appLayer, layer))
-    const router = ServiceMap.get(context, HttpRouter)
+    const router = Context.get(context, HttpRouter)
     // @effect-diagnostics effect/returnEffectInGen:off
     return router.asHttpEffect()
   }) as any
@@ -737,7 +737,7 @@ export interface Middleware<
  * ```ts
  * import { Effect } from "effect"
  * import * as Layer from "effect/Layer"
- * import * as ServiceMap from "effect/ServiceMap"
+ * import * as Context from "effect/Context"
  * import * as HttpMiddleware from "effect/unstable/http/HttpMiddleware"
  * import * as HttpRouter from "effect/unstable/http/HttpRouter"
  * import * as HttpServerResponse from "effect/unstable/http/HttpServerResponse"
@@ -746,7 +746,7 @@ export interface Middleware<
  * const CorsMiddleware = HttpRouter.middleware(HttpMiddleware.cors()).layer
  * // You can also use HttpRouter.cors() to create a CORS middleware
  *
- * class CurrentSession extends ServiceMap.Service<CurrentSession, {
+ * class CurrentSession extends Context.Service<CurrentSession, {
  *   readonly token: string
  * }>()("CurrentSession") {}
  *
@@ -815,8 +815,8 @@ const makeMiddleware = (middleware: any, options?: {
     }))
     : new MiddlewareImpl(
       Effect.isEffect(middleware) ?
-        Layer.effectServices(Effect.map(middleware, (fn) => ServiceMap.makeUnsafe(new Map([[fnContextKey, fn]])))) :
-        Layer.succeedServices(ServiceMap.makeUnsafe(new Map([[fnContextKey, middleware]]))) as any
+        Layer.effectContext(Effect.map(middleware, (fn) => Context.makeUnsafe(new Map([[fnContextKey, fn]])))) :
+        Layer.succeedContext(Context.makeUnsafe(new Map([[fnContextKey, middleware]]))) as any
     )
 
 let middlewareId = 0
@@ -844,16 +844,16 @@ class MiddlewareImpl<
     this.layerFn = layerFn
     this.dependencies = dependencies
     const contextKey = `effect/http/HttpRouter/Middleware-${++middlewareId}` as const
-    this.layer = Layer.effectServices(Effect.gen({ self: this }, function*() {
-      const context = yield* Effect.services<Scope.Scope>()
+    this.layer = Layer.effectContext(Effect.gen({ self: this }, function*() {
+      const context = yield* Effect.context<Scope.Scope>()
       const stack = [context.mapUnsafe.get(fnContextKey)]
       if (this.dependencies) {
         const memoMap = yield* Layer.CurrentMemoMap
-        const scope = ServiceMap.get(context, Scope.Scope)
+        const scope = Context.get(context, Scope.Scope)
         const depsContext = yield* Layer.buildWithMemoMap(this.dependencies, memoMap, scope)
         stack.push(...getMiddleware(depsContext))
       }
-      return ServiceMap.makeUnsafe<never>(new Map([[contextKey, stack]]))
+      return Context.makeUnsafe<never>(new Map([[contextKey, stack]]))
     })).pipe(Layer.provide(this.layerFn))
   }
 
@@ -876,8 +876,8 @@ class MiddlewareImpl<
   }
 }
 
-const middlewareCache = new WeakMap<ServiceMap.ServiceMap<never>, any>()
-const getMiddleware = (context: ServiceMap.ServiceMap<never>): Array<middleware.Fn> => {
+const middlewareCache = new WeakMap<Context.Context<never>, any>()
+const getMiddleware = (context: Context.Context<never>): Array<middleware.Fn> => {
   let arr = middlewareCache.get(context)
   if (arr) return arr
   const topLevel = Arr.empty<Array<middleware.Fn>>()
@@ -1062,7 +1062,7 @@ export const provideRequest =
       middleware<{ provides: A2 }>()(Effect.gen(function*() {
         const services = yield* Layer.build(layer as Layer.Layer<A2>)
         return (effect) =>
-          Effect.provideServices(effect, services) as Effect.Effect<
+          Effect.provideContext(effect, services) as Effect.Effect<
             HttpServerResponse.HttpServerResponse,
             Types.unhandled
           >
@@ -1172,8 +1172,8 @@ export const toWebHandler = <
   }
 ): {
   readonly handler: [HR] extends [never]
-    ? ((request: globalThis.Request, context?: ServiceMap.ServiceMap<never> | undefined) => Promise<Response>)
-    : ((request: globalThis.Request, context: ServiceMap.ServiceMap<HR>) => Promise<Response>)
+    ? ((request: globalThis.Request, context?: Context.Context<never> | undefined) => Promise<Response>)
+    : ((request: globalThis.Request, context: Context.Context<HR>) => Promise<Response>)
   readonly dispose: () => Promise<void>
 } => {
   let middleware: any = options?.middleware
@@ -1184,7 +1184,7 @@ export const toWebHandler = <
     ? Layer.provide(layer, Layer.succeed(RouterConfig)(options.routerConfig))
     : layer
   return HttpEffect.toWebHandlerLayerWith(Layer.provideMerge(appLayer, RouterLayer) as Layer.Layer<A | HttpRouter, E>, {
-    toHandler: (s) => Effect.succeed(ServiceMap.get(s, HttpRouter).asHttpEffect()),
+    toHandler: (s) => Effect.succeed(Context.get(s, HttpRouter).asHttpEffect()),
     middleware,
     memoMap: options?.memoMap
   })

package/src/unstable/http/HttpServer.ts

@@ -1,13 +1,13 @@
 /**
  * @since 4.0.0
  */
+import * as Context from "../../Context.ts"
 import * as Effect from "../../Effect.ts"
 import * as FileSystem from "../../FileSystem.ts"
 import { dual } from "../../Function.ts"
 import * as Layer from "../../Layer.ts"
 import * as Path from "../../Path.ts"
 import type * as Scope from "../../Scope.ts"
-import * as ServiceMap from "../../ServiceMap.ts"
 import * as Etag from "./Etag.ts"
 import * as HttpClient from "./HttpClient.ts"
 import * as ClientRequest from "./HttpClientRequest.ts"
@@ -20,7 +20,7 @@ import type { HttpServerResponse } from "./HttpServerResponse.ts"
  * @since 4.0.0
  * @category models
  */
-export class HttpServer extends ServiceMap.Service<HttpServer, {
+export class HttpServer extends Context.Service<HttpServer, {
   readonly serve: {
     <E, R>(effect: Effect.Effect<HttpServerResponse, E, R>): Effect.Effect<
       void,