effect 4.0.0-beta.6 → 4.0.0-beta.60

package/src/unstable/http/HttpMiddleware.ts

@@ -2,23 +2,24 @@
  * @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"
 import * as Layer from "../../Layer.ts"
+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 type { PreResponseHandler } from "./HttpEffect.ts"
 import { causeResponseStripped, exitResponse } from "./HttpServerError.ts"
 import { HttpServerRequest } from "./HttpServerRequest.ts"
 import * as Request from "./HttpServerRequest.ts"
 import * as Response from "./HttpServerResponse.ts"
 import type { HttpServerResponse } from "./HttpServerResponse.ts"
 import * as TraceContext from "./HttpTraceContext.ts"
+import { appendPreResponseHandlerUnsafe } from "./internal/preResponseHandler.ts"
 
 /**
  * @since 4.0.0
@@ -46,21 +47,29 @@ export declare namespace HttpMiddleware {
  */
 export const make = <M extends HttpMiddleware>(middleware: M): M => middleware
 
-/**
- * @since 4.0.0
- * @category Logger
- */
-export const LoggerDisabled = ServiceMap.Reference<boolean>("effect/http/HttpMiddleware/LoggerDisabled", {
-  defaultValue: constFalse
-})
+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> =>
+export const withLoggerDisabled = <A, E, R>(self: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | HttpServerRequest> =>
   Effect.withFiber((fiber) => {
-    fiber.setServices(ServiceMap.add(fiber.services, LoggerDisabled, true))
+    const request = Context.getUnsafe(fiber.context, HttpServerRequest)
+    loggerDisabledRequests.add(request.source)
     return self
   })
 
@@ -68,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 }
 )
@@ -85,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}` }
 )
@@ -99,17 +108,18 @@ 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 (fiber.getRef(LoggerDisabled)) {
+        if (loggerDisabledRequests.has(request.source)) {
           return exit
         } else if (exit._tag === "Failure") {
           const [response, cause] = causeResponseStripped(exit.cause)
           return Effect.andThen(
-            Effect.annotateLogs(Effect.log(cause ?? "Sent HTTP Response"), {
+            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
@@ -118,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
@@ -137,38 +147,38 @@ 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
     }
     const nameGenerator = fiber.getRef(SpanNameGenerator)
     const span = internalEffect.makeSpanUnsafe(fiber, nameGenerator(request), {
-      parent: TraceContext.fromHeaders(request.headers),
+      parent: Option.getOrUndefined(TraceContext.fromHeaders(request.headers)),
       kind: "server"
     })
-    const prevSpan = ServiceMap.getOption(fiber.services, ParentSpan)
-    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(ServiceMap.addOrOmit(fiber.services, ParentSpan, prevSpan))
+      fiber.setContext(prevServices)
       const endTime = fiber.getRef(Clock).currentTimeNanosUnsafe()
-      fiber.currentScheduler.scheduleTask(() => {
+      fiber.currentDispatcher.scheduleTask(() => {
         const url = Request.toURL(request)
-        if (url !== undefined && (url.username !== "" || url.password !== "")) {
-          url.username = "REDACTED"
-          url.password = "REDACTED"
+        if (Option.isSome(url) && (url.value.username !== "" || url.value.password !== "")) {
+          url.value.username = "REDACTED"
+          url.value.password = "REDACTED"
         }
         const redactedHeaderNames = fiber.getRef(Headers.CurrentRedactedNames)
         const requestHeaders = Headers.redact(request.headers, redactedHeaderNames)
         span.attribute("http.request.method", request.method)
-        if (url !== undefined) {
-          span.attribute("url.full", url.toString())
-          span.attribute("url.path", url.pathname)
-          const query = url.search.slice(1)
+        if (Option.isSome(url)) {
+          span.attribute("url.full", url.value.toString())
+          span.attribute("url.path", url.value.pathname)
+          const query = url.value.search.slice(1)
           if (query !== "") {
-            span.attribute("url.query", url.search.slice(1))
+            span.attribute("url.query", url.value.search.slice(1))
           }
-          span.attribute("url.scheme", url.protocol.slice(0, -1))
+          span.attribute("url.scheme", url.value.protocol.slice(0, -1))
         }
         if (request.headers["user-agent"] !== undefined) {
           span.attribute("user_agent.original", request.headers["user-agent"])
@@ -176,8 +186,8 @@ export const tracer: <E, R>(
         for (const name in requestHeaders) {
           span.attribute(`http.request.header.${name}`, String(requestHeaders[name]))
         }
-        if (request.remoteAddress !== undefined) {
-          span.attribute("client.address", request.remoteAddress)
+        if (Option.isSome(request.remoteAddress)) {
+          span.attribute("client.address", request.remoteAddress.value)
         }
         const response = exitResponse(exit)
         span.attribute("http.response.status_code", response.status)
@@ -205,7 +215,7 @@ export const xForwardedHeaders = make((httpApp) =>
           "host",
           request.headers["x-forwarded-host"]
         ),
-        remoteAddress: request.headers["x-forwarded-for"]?.split(",")[0].trim()
+        remoteAddress: Option.fromNullishOr(request.headers["x-forwarded-for"]?.split(",")[0].trim())
       })
       : request)
 )
@@ -218,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,
@@ -336,24 +346,14 @@ 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,
           headers: headersFromRequestOptions(request)
         }))
       }
-      const prev = fiber.getRef(PreResponseHandlers)
-      const next = prev
-        ? ((req: HttpServerRequest, res: HttpServerResponse) =>
-          Effect.flatMap(prev(req, res), (res) => preResponseHandler(req, res)))
-        : preResponseHandler
-      fiber.setServices(ServiceMap.add(fiber.services, PreResponseHandlers, next))
+      appendPreResponseHandlerUnsafe(request, preResponseHandler)
       return httpApp
     })
 }
-
-const PreResponseHandlers = ServiceMap.Reference<PreResponseHandler | undefined>(
-  "effect/http/HttpEffect/PreResponseHandlers",
-  { defaultValue: () => undefined }
-)

package/src/unstable/http/HttpPlatform.ts

@@ -1,12 +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"
@@ -17,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 & {
@@ -80,8 +81,8 @@ export const make: (impl: {
         "etag",
         Etag.toString(etag)
       )
-      if (info.mtime) {
-        ;(headers as any)["last-modified"] = info.mtime.toUTCString()
+      if (Option.isSome(info.mtime)) {
+        ;(headers as any)["last-modified"] = info.mtime.value.toUTCString()
       }
       const contentLength = end !== undefined ? end - start : Number(info.size) - start
       return impl.fileResponse(

package/src/unstable/http/HttpRouter.ts

@@ -2,17 +2,17 @@
  * @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"
+import * as Option from "../../Option.ts"
 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 UndefinedOr from "../../UndefinedOr.ts"
 import * as FindMyWay from "./FindMyWay.ts"
 import * as HttpEffect from "./HttpEffect.ts"
 import type * as HttpMethod from "./HttpMethod.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") {
@@ -177,8 +177,8 @@ export const make = Effect.gen(function*() {
           )
         }
         const route = result.handler
-        if (route.prefix !== undefined) {
-          contextMap.set(HttpServerRequest.HttpServerRequest.key, sliceRequestUrl(request, route.prefix))
+        if (Option.isSome(route.prefix)) {
+          contextMap.set(HttpServerRequest.HttpServerRequest.key, sliceRequestUrl(request, route.prefix.value))
         }
         contextMap.set(HttpServerRequest.ParsedSearchParams.key, result.searchParams)
         contextMap.set(RouteContext.key, {
@@ -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
@@ -501,7 +501,7 @@ export interface Route<E = never, R = never> {
   readonly path: PathInput
   readonly handler: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>
   readonly uninterruptible: boolean
-  readonly prefix: string | undefined
+  readonly prefix: Option.Option<string>
 }
 
 /**
@@ -527,12 +527,12 @@ const makeRoute = <E, R>(options: {
   readonly path: PathInput
   readonly handler: Effect.Effect<HttpServerResponse.HttpServerResponse, E, R>
   readonly uninterruptible?: boolean | undefined
-  readonly prefix?: string | undefined
+  readonly prefix?: Option.Option<string> | string | undefined
 }): Route<E, Exclude<R, Provided>> =>
   (({
     ...options,
     uninterruptible: options.uninterruptible ?? false,
-    prefix: options.prefix,
+    prefix: typeof options.prefix === "string" ? Option.some(options.prefix) : options.prefix ?? Option.none(),
     [RouteTypeId]: RouteTypeId
   }) as Route<E, Exclude<R, Provided>>)
 
@@ -614,9 +614,9 @@ export const prefixRoute: {
   makeRoute({
     ...self,
     path: prefixPath(self.path, prefix) as PathInput,
-    prefix: UndefinedOr.match(self.prefix, {
-      onUndefined: () => prefix as string,
-      onDefined: (existingPrefix) => prefixPath(existingPrefix, prefix) as string
+    prefix: Option.match(self.prefix, {
+      onNone: () => prefix as string,
+      onSome: (existingPrefix) => prefixPath(existingPrefix, prefix) as string
     })
   }))
 
@@ -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,
@@ -36,6 +36,7 @@ export class HttpServer extends ServiceMap.Service<HttpServer, {
       Exclude<R, HttpServerRequest> | Scope.Scope
     >
   }
+
   readonly address: Address
 }>()("effect/http/HttpServer") {}
 
@@ -127,10 +128,7 @@ export const serve: {
   HttpServer | Exclude<Effect.Services<App>, HttpServerRequest | Scope.Scope>
 > =>
   Layer.effectDiscard(
-    Effect.flatMap(
-      HttpServer.asEffect(),
-      (server) => server.serve(effect, middleware!)
-    )
+    HttpServer.use((server) => server.serve(effect, middleware!))
   ) as any)
 
 /**
@@ -180,11 +178,7 @@ export const serveEffect: {
   void,
   never,
   Scope.Scope | HttpServer | Exclude<Effect.Services<App>, HttpServerRequest>
-> =>
-  Effect.flatMap(
-    HttpServer.asEffect(),
-    (server) => server.serve(effect, middleware!)
-  ) as any)
+> => HttpServer.use((server) => server.serve(effect, middleware!)) as any)
 
 /**
  * @since 4.0.0