@effect/platform 0.57.7 → 0.58.0

package/src/internal/{http/router.ts → httpRouter.ts}

@@ -12,28 +12,28 @@ import * as Option from "effect/Option"
 import * as Predicate from "effect/Predicate"
 import * as Tracer from "effect/Tracer"
 import * as FindMyWay from "find-my-way-ts"
-import type * as App from "../../Http/App.js"
-import type * as Method from "../../Http/Method.js"
-import type * as Router from "../../Http/Router.js"
-import * as Error from "../../Http/ServerError.js"
-import * as ServerRequest from "../../Http/ServerRequest.js"
-import type * as ServerResponse from "../../Http/ServerResponse.js"
+import type * as App from "../HttpApp.js"
+import type * as Method from "../HttpMethod.js"
+import type * as Router from "../HttpRouter.js"
+import * as Error from "../HttpServerError.js"
+import * as ServerRequest from "../HttpServerRequest.js"
+import type * as ServerResponse from "../HttpServerResponse.js"
 
 /** @internal */
-export const TypeId: Router.TypeId = Symbol.for("@effect/platform/Http/Router") as Router.TypeId
+export const TypeId: Router.TypeId = Symbol.for("@effect/platform/HttpRouter") as Router.TypeId
 
 /** @internal */
-export const RouteTypeId: Router.RouteTypeId = Symbol.for("@effect/platform/Http/Router/Route") as Router.RouteTypeId
+export const RouteTypeId: Router.RouteTypeId = Symbol.for("@effect/platform/HttpRouter/Route") as Router.RouteTypeId
 
 /** @internal */
 export const RouteContextTypeId: Router.RouteContextTypeId = Symbol.for(
-  "@effect/platform/Http/Router/RouteContext"
+  "@effect/platform/HttpRouter/RouteContext"
 ) as Router.RouteContextTypeId
 
 /** @internal */
-export const RouteContext = Context.GenericTag<Router.RouteContext>("@effect/platform/Http/Router/RouteContext")
+export const RouteContext = Context.GenericTag<Router.RouteContext>("@effect/platform/HttpRouter/RouteContext")
 
-const isRouter = (u: unknown): u is Router.Router<unknown, unknown> => Predicate.hasProperty(u, TypeId)
+const isRouter = (u: unknown): u is Router.HttpRouter<unknown, unknown> => Predicate.hasProperty(u, TypeId)
 
 /** @internal */
 export const params = Effect.map(RouteContext, (_) => _.params)
@@ -42,7 +42,7 @@ export const params = Effect.map(RouteContext, (_) => _.params)
 export const schemaJson = <
   R,
   I extends Partial<{
-    readonly method: Method.Method
+    readonly method: Method.HttpMethod
     readonly url: string
     readonly cookies: Readonly<Record<string, string | undefined>>
     readonly headers: Readonly<Record<string, string | undefined>>
@@ -57,9 +57,9 @@ export const schemaJson = <
 ) => {
   const parse = Schema.decodeUnknown(schema, options)
   return Effect.flatMap(
-    Effect.context<ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams | Router.RouteContext>(),
+    Effect.context<ServerRequest.HttpServerRequest | ServerRequest.ParsedSearchParams | Router.RouteContext>(),
     (context) => {
-      const request = Context.get(context, ServerRequest.ServerRequest)
+      const request = Context.get(context, ServerRequest.HttpServerRequest)
       const searchParams = Context.get(context, ServerRequest.ParsedSearchParams)
       const routeContext = Context.get(context, RouteContext)
       return Effect.flatMap(request.json, (body) =>
@@ -80,7 +80,7 @@ export const schemaJson = <
 export const schemaNoBody = <
   R,
   I extends Partial<{
-    readonly method: Method.Method
+    readonly method: Method.HttpMethod
     readonly url: string
     readonly cookies: Readonly<Record<string, string | undefined>>
     readonly headers: Readonly<Record<string, string | undefined>>
@@ -94,9 +94,9 @@ export const schemaNoBody = <
 ) => {
   const parse = Schema.decodeUnknown(schema, options)
   return Effect.flatMap(
-    Effect.context<ServerRequest.ServerRequest | ServerRequest.ParsedSearchParams | Router.RouteContext>(),
+    Effect.context<ServerRequest.HttpServerRequest | ServerRequest.ParsedSearchParams | Router.RouteContext>(),
     (context) => {
-      const request = Context.get(context, ServerRequest.ServerRequest)
+      const request = Context.get(context, ServerRequest.HttpServerRequest)
       const searchParams = Context.get(context, ServerRequest.ParsedSearchParams)
       const routeContext = Context.get(context, RouteContext)
       return parse({
@@ -137,10 +137,10 @@ export const schemaPathParams = <A, I extends Readonly<Record<string, string | u
 }
 
 class RouterImpl<E = never, R = never> extends Effectable.StructuralClass<
-  ServerResponse.ServerResponse,
+  ServerResponse.HttpServerResponse,
   E | Error.RouteNotFound,
   Exclude<R, Router.RouteContext>
-> implements Router.Router<E, R> {
+> implements Router.HttpRouter<E, R> {
   readonly [TypeId]: Router.TypeId
   constructor(
     readonly routes: Chunk.Chunk<Router.Route<E, R>>,
@@ -157,7 +157,7 @@ class RouterImpl<E = never, R = never> extends Effectable.StructuralClass<
     this.httpApp = toHttpApp(this) as any
   }
   private httpApp: Effect.Effect<
-    ServerResponse.ServerResponse,
+    ServerResponse.HttpServerResponse,
     E | Error.RouteNotFound,
     Exclude<R, Router.RouteContext>
   >
@@ -181,7 +181,7 @@ class RouterImpl<E = never, R = never> extends Effectable.StructuralClass<
 }
 
 const toHttpApp = <E, R>(
-  self: Router.Router<E, R>
+  self: Router.HttpRouter<E, R>
 ): App.Default<E | Error.RouteNotFound, R> => {
   const router = FindMyWay.make<Router.Route<E, R>>()
   const mounts = Chunk.toReadonlyArray(self.mounts).map(([path, app, options]) =>
@@ -209,19 +209,19 @@ const toHttpApp = <E, R>(
     }
   })
   return Effect.withFiberRuntime<
-    ServerResponse.ServerResponse,
+    ServerResponse.HttpServerResponse,
     E | Error.RouteNotFound,
-    R | ServerRequest.ServerRequest
+    R | ServerRequest.HttpServerRequest
   >((fiber) => {
     const context = Context.unsafeMake(new Map(fiber.getFiberRef(FiberRef.currentContext).unsafeMap))
-    const request = Context.unsafeGet(context, ServerRequest.ServerRequest)
+    const request = Context.unsafeGet(context, ServerRequest.HttpServerRequest)
     if (mountsLen > 0) {
       for (let i = 0; i < mountsLen; i++) {
         const [path, routeContext, options] = mounts[i]
         if (request.url.startsWith(path)) {
           context.unsafeMap.set(RouteContext.key, routeContext)
           if (options?.includePrefix !== true) {
-            context.unsafeMap.set(ServerRequest.ServerRequest.key, sliceRequestUrl(request, path))
+            context.unsafeMap.set(ServerRequest.HttpServerRequest.key, sliceRequestUrl(request, path))
           }
           return Effect.locally(
             routeContext.route.handler as App.Default<E, R>,
@@ -241,7 +241,7 @@ const toHttpApp = <E, R>(
     }
     const route = result.handler
     if (route.prefix._tag === "Some") {
-      context.unsafeMap.set(ServerRequest.ServerRequest.key, sliceRequestUrl(request, route.prefix.value))
+      context.unsafeMap.set(ServerRequest.HttpServerRequest.key, sliceRequestUrl(request, route.prefix.value))
     }
     context.unsafeMap.set(ServerRequest.ParsedSearchParams.key, result.searchParams)
     context.unsafeMap.set(RouteContext.key, new RouteContextImpl(route, result.params))
@@ -255,9 +255,9 @@ const toHttpApp = <E, R>(
       (route.uninterruptible ?
         route.handler :
         Effect.interruptible(route.handler)) as Effect.Effect<
-          ServerResponse.ServerResponse,
+          ServerResponse.HttpServerResponse,
           E,
-          Router.Router.ExcludeProvided<R>
+          Router.HttpRouter.ExcludeProvided<R>
         >,
       FiberRef.currentContext,
       context
@@ -265,7 +265,7 @@ const toHttpApp = <E, R>(
   })
 }
 
-function sliceRequestUrl(request: ServerRequest.ServerRequest, prefix: string) {
+function sliceRequestUrl(request: ServerRequest.HttpServerRequest, prefix: string) {
   const prefexLen = prefix.length
   return request.modify({ url: request.url.length <= prefexLen ? "/" : request.url.slice(prefexLen) })
 }
@@ -273,7 +273,7 @@ function sliceRequestUrl(request: ServerRequest.ServerRequest, prefix: string) {
 class RouteImpl<E = never, R = never> extends Inspectable.Class implements Router.Route<E, R> {
   readonly [RouteTypeId]: Router.RouteTypeId
   constructor(
-    readonly method: Method.Method | "*",
+    readonly method: Method.HttpMethod | "*",
     readonly path: Router.PathInput,
     readonly handler: Router.Route.Handler<E, R>,
     readonly prefix = Option.none<string>(),
@@ -284,7 +284,7 @@ class RouteImpl<E = never, R = never> extends Inspectable.Class implements Route
   }
   toJSON(): unknown {
     return {
-      _id: "@effect/platform/Http/Router/Route",
+      _id: "@effect/platform/HttpRouter/Route",
       method: this.method,
       path: this.path,
       prefix: this.prefix.toJSON()
@@ -303,24 +303,24 @@ class RouteContextImpl implements Router.RouteContext {
 }
 
 /** @internal */
-export const empty: Router.Router<never> = new RouterImpl(Chunk.empty(), Chunk.empty())
+export const empty: Router.HttpRouter<never> = new RouterImpl(Chunk.empty(), Chunk.empty())
 
 /** @internal */
 export const fromIterable = <R extends Router.Route<any, any>>(
   routes: Iterable<R>
-): Router.Router<
+): Router.HttpRouter<
   R extends Router.Route<infer E, infer _> ? E : never,
   R extends Router.Route<infer _, infer Env> ? Env : never
 > => new RouterImpl(Chunk.fromIterable(routes), Chunk.empty()) as any
 
 /** @internal */
 export const makeRoute = <E, R>(
-  method: Method.Method,
+  method: Method.HttpMethod,
   path: Router.PathInput,
   handler: Router.Route.Handler<E, R>,
   prefix: Option.Option<string> = Option.none(),
   uninterruptible = false
-): Router.Route<E, Router.Router.ExcludeProvided<R>> =>
+): Router.Route<E, Router.HttpRouter.ExcludeProvided<R>> =>
   new RouteImpl(
     method,
     path,
@@ -331,8 +331,10 @@ export const makeRoute = <E, R>(
 
 /** @internal */
 export const concat = dual<
-  <R1, E1>(that: Router.Router<E1, R1>) => <E, R>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
-  <E, R, E1, R1>(self: Router.Router<E, R>, that: Router.Router<E1, R1>) => Router.Router<E | E1, R | R1>
+  <R1, E1>(
+    that: Router.HttpRouter<E1, R1>
+  ) => <E, R>(self: Router.HttpRouter<E, R>) => Router.HttpRouter<E | E1, R | R1>,
+  <E, R, E1, R1>(self: Router.HttpRouter<E, R>, that: Router.HttpRouter<E1, R1>) => Router.HttpRouter<E | E1, R | R1>
 >(2, (self, that) => new RouterImpl(Chunk.appendAll(self.routes, that.routes) as any, self.mounts))
 
 const removeTrailingSlash = (
@@ -341,8 +343,8 @@ const removeTrailingSlash = (
 
 /** @internal */
 export const prefixAll = dual<
-  (prefix: Router.PathInput) => <E, R>(self: Router.Router<E, R>) => Router.Router<E, R>,
-  <E, R>(self: Router.Router<E, R>, prefix: Router.PathInput) => Router.Router<E, R>
+  (prefix: Router.PathInput) => <E, R>(self: Router.HttpRouter<E, R>) => Router.HttpRouter<E, R>,
+  <E, R>(self: Router.HttpRouter<E, R>, prefix: Router.PathInput) => Router.HttpRouter<E, R>
 >(
   2,
   (self, prefix) => {
@@ -368,13 +370,13 @@ export const prefixAll = dual<
 export const mount = dual<
   <R1, E1>(
     path: `/${string}`,
-    that: Router.Router<E1, R1>
-  ) => <E, R>(self: Router.Router<E, R>) => Router.Router<E | E1, R | R1>,
+    that: Router.HttpRouter<E1, R1>
+  ) => <E, R>(self: Router.HttpRouter<E, R>) => Router.HttpRouter<E | E1, R | R1>,
   <E, R, E1, R1>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     path: `/${string}`,
-    that: Router.Router<E1, R1>
-  ) => Router.Router<E | E1, R | R1>
+    that: Router.HttpRouter<E1, R1>
+  ) => Router.HttpRouter<E | E1, R | R1>
 >(
   3,
   (self, path, that) => concat(self, prefixAll(that, path))
@@ -389,31 +391,31 @@ export const mountApp = dual<
       readonly includePrefix?: boolean | undefined
     } | undefined
   ) => <E, R>(
-    self: Router.Router<E, R>
-  ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
+    self: Router.HttpRouter<E, R>
+  ) => Router.HttpRouter<E | E1, R | Router.HttpRouter.ExcludeProvided<R1>>,
   <E, R, E1, R1>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
     options?: {
       readonly includePrefix?: boolean | undefined
     } | undefined
-  ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>
+  ) => Router.HttpRouter<E | E1, R | Router.HttpRouter.ExcludeProvided<R1>>
 >(
   (args) => Predicate.hasProperty(args[0], TypeId),
   <E, R, E1, R1>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     path: `/${string}`,
     that: App.Default<E1, R1>,
     options?: {
       readonly includePrefix?: boolean | undefined
     } | undefined
-  ): Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>> =>
+  ): Router.HttpRouter<E | E1, R | Router.HttpRouter.ExcludeProvided<R1>> =>
     new RouterImpl<any, any>(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that, options])) as any
 )
 
 /** @internal */
-export const route = (method: Method.Method | "*"): {
+export const route = (method: Method.HttpMethod | "*"): {
   <R1, E1>(
     path: Router.PathInput,
     handler: Router.Route.Handler<E1, R1>,
@@ -421,32 +423,32 @@ export const route = (method: Method.Method | "*"): {
       readonly uninterruptible?: boolean | undefined
     } | undefined
   ): <E, R>(
-    self: Router.Router<E, R>
-  ) => Router.Router<E1 | E, R | Router.Router.ExcludeProvided<R1>>
+    self: Router.HttpRouter<E, R>
+  ) => Router.HttpRouter<E1 | E, R | Router.HttpRouter.ExcludeProvided<R1>>
   <E, R, E1, R1>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     path: Router.PathInput,
     handler: Router.Route.Handler<E1, R1>,
     options?: {
       readonly uninterruptible?: boolean | undefined
     } | undefined
-  ): Router.Router<E1 | E, R | Router.Router.ExcludeProvided<R1>>
+  ): Router.HttpRouter<E1 | E, R | Router.HttpRouter.ExcludeProvided<R1>>
 } =>
   dual<
     <R1, E1>(
       path: Router.PathInput,
       handler: Router.Route.Handler<R1, E1>
     ) => <E, R>(
-      self: Router.Router<E, R>
-    ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>,
+      self: Router.HttpRouter<E, R>
+    ) => Router.HttpRouter<E | E1, R | Router.HttpRouter.ExcludeProvided<R1>>,
     <E, R, E1, R1>(
-      self: Router.Router<E, R>,
+      self: Router.HttpRouter<E, R>,
       path: Router.PathInput,
       handler: Router.Route.Handler<E1, R1>,
       options?: {
         readonly uninterruptible?: boolean | undefined
       } | undefined
-    ) => Router.Router<E | E1, R | Router.Router.ExcludeProvided<R1>>
+    ) => Router.HttpRouter<E | E1, R | Router.HttpRouter.ExcludeProvided<R1>>
   >((args) => isRouter(args[0]), (self, path, handler, options) =>
     new RouterImpl<any, any>(
       Chunk.append(
@@ -490,11 +492,11 @@ export const options = route("OPTIONS")
 export const use = dual<
   <E, R, R1, E1>(
     f: (self: Router.Route.Handler<E, R>) => App.Default<E1, R1>
-  ) => (self: Router.Router<E, R>) => Router.Router<E1, Router.Router.ExcludeProvided<R1>>,
+  ) => (self: Router.HttpRouter<E, R>) => Router.HttpRouter<E1, Router.HttpRouter.ExcludeProvided<R1>>,
   <E, R, R1, E1>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     f: (self: Router.Route.Handler<E, R>) => App.Default<E1, R1>
-  ) => Router.Router<E1, Router.Router.ExcludeProvided<R1>>
+  ) => Router.HttpRouter<E1, Router.HttpRouter.ExcludeProvided<R1>>
 >(2, (self, f) =>
   new RouterImpl<any, any>(
     Chunk.map(
@@ -511,22 +513,22 @@ export const use = dual<
 export const catchAll = dual<
   <E, E2, R2>(
     f: (e: E) => Router.Route.Handler<E2, R2>
-  ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
+  ) => <R>(self: Router.HttpRouter<E, R>) => Router.HttpRouter<E2, R | Router.HttpRouter.ExcludeProvided<R2>>,
   <E, R, E2, R2>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     f: (e: E) => Router.Route.Handler<E2, R2>
-  ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
+  ) => Router.HttpRouter<E2, R | Router.HttpRouter.ExcludeProvided<R2>>
 >(2, (self, f) => use(self, Effect.catchAll(f)))
 
 /** @internal */
 export const catchAllCause = dual<
   <E, E2, R2>(
     f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
-  ) => <R>(self: Router.Router<E, R>) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>,
+  ) => <R>(self: Router.HttpRouter<E, R>) => Router.HttpRouter<E2, R | Router.HttpRouter.ExcludeProvided<R2>>,
   <E, R, E2, R2>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     f: (e: Cause.Cause<E>) => Router.Route.Handler<E2, R2>
-  ) => Router.Router<E2, R | Router.Router.ExcludeProvided<R2>>
+  ) => Router.HttpRouter<E2, R | Router.HttpRouter.ExcludeProvided<R2>>
 >(2, (self, f) => use(self, Effect.catchAllCause(f)))
 
 /** @internal */
@@ -535,13 +537,13 @@ export const catchTag = dual<
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<E1, R1>
   ) => <R>(
-    self: Router.Router<E, R>
-  ) => Router.Router<Exclude<E, { _tag: K }> | E1, R | Router.Router.ExcludeProvided<R1>>,
+    self: Router.HttpRouter<E, R>
+  ) => Router.HttpRouter<Exclude<E, { _tag: K }> | E1, R | Router.HttpRouter.ExcludeProvided<R1>>,
   <E, R, K extends (E extends { _tag: string } ? E["_tag"] : never), E1, R1>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<E1, R1>
-  ) => Router.Router<Exclude<E, { _tag: K }> | E1, R | Router.Router.ExcludeProvided<R1>>
+  ) => Router.HttpRouter<Exclude<E, { _tag: K }> | E1, R | Router.HttpRouter.ExcludeProvided<R1>>
 >(3, (self, k, f) => use(self, Effect.catchTag(k, f)))
 
 /** @internal */
@@ -554,13 +556,13 @@ export const catchTags: {
       {})
   >(
     cases: Cases
-  ): <R>(self: Router.Router<E, R>) => Router.Router<
+  ): <R>(self: Router.HttpRouter<E, R>) => Router.HttpRouter<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
     }[keyof Cases],
     | R
-    | Router.Router.ExcludeProvided<
+    | Router.HttpRouter.ExcludeProvided<
       {
         [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
       }[keyof Cases]
@@ -574,39 +576,39 @@ export const catchTags: {
       } :
       {})
   >(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     cases: Cases
-  ): Router.Router<
+  ): Router.HttpRouter<
     | Exclude<E, { _tag: keyof Cases }>
     | {
       [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, infer E, any>) ? E : never
     }[keyof Cases],
     | R
-    | Router.Router.ExcludeProvided<
+    | Router.HttpRouter.ExcludeProvided<
       {
         [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
       }[keyof Cases]
     >
   >
-} = dual(2, (self: Router.Router<any, any>, cases: {}) => use(self, Effect.catchTags(cases)))
+} = dual(2, (self: Router.HttpRouter<any, any>, cases: {}) => use(self, Effect.catchTags(cases)))
 
 export const provideService = dual<
   <T extends Context.Tag<any, any>>(
     tag: T,
     service: Context.Tag.Service<T>
   ) => <E, R>(
-    self: Router.Router<E, R>
-  ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>,
+    self: Router.HttpRouter<E, R>
+  ) => Router.HttpRouter<E, Exclude<R, Context.Tag.Identifier<T>>>,
   <E, R, T extends Context.Tag<any, any>>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     tag: T,
     service: Context.Tag.Service<T>
-  ) => Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>>
+  ) => Router.HttpRouter<E, Exclude<R, Context.Tag.Identifier<T>>>
 >(3, <E, R, T extends Context.Tag<any, any>>(
-  self: Router.Router<E, R>,
+  self: Router.HttpRouter<E, R>,
   tag: T,
   service: Context.Tag.Service<T>
-): Router.Router<E, Exclude<R, Context.Tag.Identifier<T>>> => use(self, Effect.provideService(tag, service)))
+): Router.HttpRouter<E, Exclude<R, Context.Tag.Identifier<T>>> => use(self, Effect.provideService(tag, service)))
 
 /* @internal */
 export const provideServiceEffect = dual<
@@ -614,33 +616,33 @@ export const provideServiceEffect = dual<
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ) => <E, R>(
-    self: Router.Router<E, R>
-  ) => Router.Router<
+    self: Router.HttpRouter<E, R>
+  ) => Router.HttpRouter<
     E | E1,
     Exclude<
-      R | Router.Router.ExcludeProvided<R1>,
+      R | Router.HttpRouter.ExcludeProvided<R1>,
       Context.Tag.Identifier<T>
     >
   >,
   <E, R, T extends Context.Tag<any, any>, R1, E1>(
-    self: Router.Router<E, R>,
+    self: Router.HttpRouter<E, R>,
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-  ) => Router.Router<
+  ) => Router.HttpRouter<
     E | E1,
     Exclude<
-      R | Router.Router.ExcludeProvided<R1>,
+      R | Router.HttpRouter.ExcludeProvided<R1>,
       Context.Tag.Identifier<T>
     >
   >
 >(3, <E, R, T extends Context.Tag<any, any>, R1, E1>(
-  self: Router.Router<E, R>,
+  self: Router.HttpRouter<E, R>,
   tag: T,
   effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-): Router.Router<
+): Router.HttpRouter<
   E | E1,
   Exclude<
-    R | Router.Router.ExcludeProvided<R1>,
+    R | Router.HttpRouter.ExcludeProvided<R1>,
     Context.Tag.Identifier<T>
   >
 > => use(self, Effect.provideServiceEffect(tag, effect)) as any)