@effect/platform 0.17.0 → 0.18.0

package/src/Http/UrlParams.ts

@@ -1,9 +1,9 @@
 /**
  * @since 1.0.0
  */
-import * as Chunk from "@effect/data/Chunk"
-import { dual } from "@effect/data/Function"
-import * as Effect from "@effect/io/Effect"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
 
 /**
  * @since 1.0.0

package/src/KeyValueStore.ts

@@ -1,16 +1,16 @@
 /**
  * @since 1.0.0
  */
-import type * as Context from "@effect/data/Context"
-import type * as Option from "@effect/data/Option"
-import type * as Effect from "@effect/io/Effect"
-import type * as Layer from "@effect/io/Layer"
 import type * as PlatformError from "@effect/platform/Error"
 import type * as FileSystem from "@effect/platform/FileSystem"
 import * as internal from "@effect/platform/internal/keyValueStore"
 import type * as Path from "@effect/platform/Path"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
+import type * as Context from "effect/Context"
+import type * as Effect from "effect/Effect"
+import type * as Layer from "effect/Layer"
+import type * as Option from "effect/Option"
 
 /**
  * @since 1.0.0

package/src/Path.ts

@@ -2,11 +2,11 @@
  * @since 1.0.0
  */
 
-import type { Tag } from "@effect/data/Context"
-import type { Effect } from "@effect/io/Effect"
-import type { Layer } from "@effect/io/Layer"
 import type { BadArgument } from "@effect/platform/Error"
 import * as internal from "@effect/platform/internal/path"
+import type { Tag } from "effect/Context"
+import type { Effect } from "effect/Effect"
+import type { Layer } from "effect/Layer"
 
 /**
  * @since 1.0.0

package/src/Runtime.ts

@@ -1,9 +1,9 @@
 /**
  * @since 1.0.0
  */
-import * as Cause from "@effect/io/Cause"
-import type { Effect } from "@effect/io/Effect"
-import * as Exit from "@effect/io/Exit"
+import * as Cause from "effect/Cause"
+import type { Effect } from "effect/Effect"
+import * as Exit from "effect/Exit"
 
 /**
  * @category model

package/src/index.ts

@@ -0,0 +1,49 @@
+/**
+ * @since 1.0.0
+ */
+export * as Command from "@effect/platform/Command"
+
+/**
+ * @since 1.0.0
+ */
+export * as CommandExecutor from "@effect/platform/CommandExecutor"
+
+/**
+ * @since 1.0.0
+ */
+export * as Effectify from "@effect/platform/Effectify"
+
+/**
+ * @since 1.0.0
+ */
+export * as Error from "@effect/platform/Error"
+
+/**
+ * @since 1.0.0
+ */
+export * as FileSystem from "@effect/platform/FileSystem"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpClient from "@effect/platform/HttpClient"
+
+/**
+ * @since 1.0.0
+ */
+export * as HttpServer from "@effect/platform/HttpServer"
+
+/**
+ * @since 1.0.0
+ */
+export * as KeyValueStore from "@effect/platform/KeyValueStore"
+
+/**
+ * @since 1.0.0
+ */
+export * as Path from "@effect/platform/Path"
+
+/**
+ * @since 1.0.0
+ */
+export * as Runtime from "@effect/platform/Runtime"

package/src/internal/command.ts

@@ -1,15 +1,15 @@
-import * as Chunk from "@effect/data/Chunk"
-import { dual } from "@effect/data/Function"
-import * as HashMap from "@effect/data/HashMap"
-import * as Option from "@effect/data/Option"
-import { pipeArguments } from "@effect/data/Pipeable"
-import type ReadonlyArray from "@effect/data/ReadonlyArray"
-import * as Effect from "@effect/io/Effect"
 import type * as Command from "@effect/platform/Command"
 import type * as CommandExecutor from "@effect/platform/CommandExecutor"
 import type { PlatformError } from "@effect/platform/Error"
 import * as commandExecutor from "@effect/platform/internal/commandExecutor"
-import * as Stream from "@effect/stream/Stream"
+import * as Chunk from "effect/Chunk"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import * as HashMap from "effect/HashMap"
+import * as Option from "effect/Option"
+import { pipeArguments } from "effect/Pipeable"
+import type ReadonlyArray from "effect/ReadonlyArray"
+import * as Stream from "effect/Stream"
 
 /** @internal */
 export const CommandTypeId: Command.CommandTypeId = Symbol.for("@effect/platform/Command") as Command.CommandTypeId

package/src/internal/commandExecutor.ts

@@ -1,11 +1,11 @@
-import * as Brand from "@effect/data/Brand"
-import * as Chunk from "@effect/data/Chunk"
-import { Tag } from "@effect/data/Context"
-import { pipe } from "@effect/data/Function"
-import * as Effect from "@effect/io/Effect"
 import type * as _CommandExecutor from "@effect/platform/CommandExecutor"
-import * as Sink from "@effect/stream/Sink"
-import * as Stream from "@effect/stream/Stream"
+import * as Brand from "effect/Brand"
+import * as Chunk from "effect/Chunk"
+import { Tag } from "effect/Context"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
+import * as Sink from "effect/Sink"
+import * as Stream from "effect/Stream"
 
 /** @internal */
 export const ProcessTypeId: _CommandExecutor.ProcessTypeId = Symbol.for(

package/src/internal/effectify.ts

@@ -1,5 +1,5 @@
-import * as Effect from "@effect/io/Effect"
 import type { Effectify, EffectifyError } from "@effect/platform/Effectify"
+import * as Effect from "effect/Effect"
 
 /** @internal */
 export const effectify: {

package/src/internal/error.ts

@@ -1,5 +1,5 @@
-import * as Data from "@effect/data/Data"
 import type * as Error from "@effect/platform/Error"
+import * as Data from "effect/Data"
 
 /** @internal */
 export const PlatformErrorTypeId: Error.PlatformErrorTypeId = Symbol.for(

package/src/internal/fileSystem.ts

@@ -1,11 +1,11 @@
-import { Tag } from "@effect/data/Context"
-import { identity, pipe } from "@effect/data/Function"
-import * as Option from "@effect/data/Option"
-import * as Effect from "@effect/io/Effect"
 import * as Error from "@effect/platform/Error"
 import type { File, FileSystem, Size as Size_, SizeInput, StreamOptions } from "@effect/platform/FileSystem"
-import * as Sink from "@effect/stream/Sink"
-import * as Stream from "@effect/stream/Stream"
+import { Tag } from "effect/Context"
+import * as Effect from "effect/Effect"
+import { identity, pipe } from "effect/Function"
+import * as Option from "effect/Option"
+import * as Sink from "effect/Sink"
+import * as Stream from "effect/Stream"
 
 /** @internal */
 export const tag = Tag<FileSystem>("@effect/platform/FileSystem")

package/src/internal/http/body.ts

@@ -1,11 +1,11 @@
-import * as Data from "@effect/data/Data"
-import { identity } from "@effect/data/Function"
-import * as Effect from "@effect/io/Effect"
 import type * as PlatformError from "@effect/platform/Error"
 import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import * as Schema from "@effect/schema/Schema"
-import * as Stream_ from "@effect/stream/Stream"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import { identity } from "effect/Function"
+import * as Stream_ from "effect/Stream"
 
 /** @internal */
 export const TypeId: Body.TypeId = Symbol.for(

package/src/internal/http/client.ts

@@ -1,17 +1,7 @@
-import * as Context from "@effect/data/Context"
-import { dual, pipe } from "@effect/data/Function"
-import * as Option from "@effect/data/Option"
-import { pipeArguments } from "@effect/data/Pipeable"
-import type * as Predicate from "@effect/data/Predicate"
-import * as Effect from "@effect/io/Effect"
-import * as Layer from "@effect/io/Layer"
-import type * as Schedule from "@effect/io/Schedule"
-import type * as Scope from "@effect/io/Scope"
 import type * as Body from "@effect/platform/Http/Body"
 import type * as Client from "@effect/platform/Http/Client"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
-import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
 import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
 import * as Method from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
@@ -21,7 +11,16 @@ import * as internalRequest from "@effect/platform/internal/http/clientRequest"
 import * as internalResponse from "@effect/platform/internal/http/clientResponse"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
-import * as Stream from "@effect/stream/Stream"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import { dual, pipe } from "effect/Function"
+import * as Layer from "effect/Layer"
+import * as Option from "effect/Option"
+import { pipeArguments } from "effect/Pipeable"
+import type * as Predicate from "effect/Predicate"
+import type * as Schedule from "effect/Schedule"
+import type * as Scope from "effect/Scope"
+import * as Stream from "effect/Stream"
 
 /** @internal */
 export const TypeId: Client.TypeId = Symbol.for("@effect/platform/Http/Client") as Client.TypeId
@@ -36,20 +35,14 @@ const clientProto = {
   }
 }
 
-const setProto = <R, E, A>(
+/** @internal */
+export const make = <R, E, A>(
   f: (request: ClientRequest.ClientRequest) => Effect.Effect<R, E, A>
 ) => {
   Object.setPrototypeOf(f, clientProto)
   return f as Client.Client<R, E, A>
 }
 
-/** @internal */
-export const make = (
-  f: (
-    request: ClientRequest.ClientRequest
-  ) => Effect.Effect<never, Error.HttpClientError, ClientResponse.ClientResponse>
-): Client.Client.Default => setProto(f)
-
 /** @internal */
 export const fetch = (
   options: RequestInit = {}
@@ -108,6 +101,7 @@ const convertBody = (body: Body.Body): BodyInit | undefined => {
   }
 }
 
+/** @internal */
 export const fetchOk = (
   options: RequestInit = {}
 ): Client.Client.Default => filterStatusOk(fetch(options))
@@ -115,6 +109,28 @@ export const fetchOk = (
 /** @internal */
 export const layer = Layer.succeed(tag, fetch())
 
+/** @internal */
+export const transform = dual<
+  <R, E, A, R1, E1, A1>(
+    f: (client: Client.Client<R, E, A>) => (request: ClientRequest.ClientRequest) => Effect.Effect<R1, E1, A1>
+  ) => (self: Client.Client<R, E, A>) => Client.Client<R1, E1, A1>,
+  <R, E, A, R1, E1, A1>(
+    self: Client.Client<R, E, A>,
+    f: (client: Client.Client<R, E, A>) => (request: ClientRequest.ClientRequest) => Effect.Effect<R1, E1, A1>
+  ) => Client.Client<R1, E1, A1>
+>(2, (self, f) => make(f(self)))
+
+/** @internal */
+export const transformResponse = dual<
+  <R, E, A, R1, E1, A1>(
+    f: (effect: Effect.Effect<R, E, A>) => Effect.Effect<R1, E1, A1>
+  ) => (self: Client.Client<R, E, A>) => Client.Client<R1, E1, A1>,
+  <R, E, A, R1, E1, A1>(
+    self: Client.Client<R, E, A>,
+    f: (effect: Effect.Effect<R, E, A>) => Effect.Effect<R1, E1, A1>
+  ) => Client.Client<R1, E1, A1>
+>(2, (self, f) => make((request) => f(self(request))))
+
 /** @internal */
 export const catchTag: {
   <K extends (E extends { _tag: string } ? E["_tag"] : never), E, R1, E1, A1>(
@@ -135,7 +151,7 @@ export const catchTag: {
     tag: K,
     f: (e: Extract<E, { _tag: K }>) => Effect.Effect<R1, E1, A1>
   ): Client.Client<R1 | R, E1 | Exclude<E, { _tag: K }>, A1 | A> =>
-    setProto((request) => Effect.catchTag(self(request), tag, f))
+    make((request) => Effect.catchTag(self(request), tag, f))
 )
 
 /** @internal */
@@ -242,7 +258,7 @@ export const catchTags: {
       ) => Effect.Effect<any, any, infer A> ? A
         : never
     }[keyof Cases]
-  > => setProto((request) => Effect.catchTags(self(request), cases))
+  > => make((request) => Effect.catchTags(self(request), cases))
 )
 
 /** @internal */
@@ -259,7 +275,7 @@ export const catchAll: {
   <R, E, A, R2, E2, A2>(
     self: Client.Client<R, E, A>,
     f: (e: E) => Effect.Effect<R2, E2, A2>
-  ): Client.Client<R | R2, E2, A2 | A> => setProto((request) => Effect.catchAll(self(request), f))
+  ): Client.Client<R | R2, E2, A2 | A> => make((request) => Effect.catchAll(self(request), f))
 )
 
 /** @internal */
@@ -272,7 +288,7 @@ export const filterOrElse = dual<
     f: Predicate.Predicate<A>,
     orElse: (a: A) => Effect.Effect<R2, E2, B>
   ) => Client.Client<R2 | R, E2 | E, A | B>
->(3, (self, f, orElse) => setProto((request) => Effect.filterOrElse(self(request), f, orElse)))
+>(3, (self, f, orElse) => make((request) => Effect.filterOrElse(self(request), f, orElse)))
 
 /** @internal */
 export const filterOrFail = dual<
@@ -284,7 +300,7 @@ export const filterOrFail = dual<
     f: Predicate.Predicate<A>,
     orFailWith: (a: A) => E2
   ) => Client.Client<R, E2 | E, A>
->(3, (self, f, orFailWith) => setProto((request) => Effect.filterOrFail(self(request), f, orFailWith)))
+>(3, (self, f, orFailWith) => make((request) => Effect.filterOrFail(self(request), f, orFailWith)))
 
 /** @internal */
 export const filterStatus = dual<
@@ -298,7 +314,7 @@ export const filterStatus = dual<
 >(
   2,
   (self, f) =>
-    setProto((request) =>
+    make((request) =>
       Effect.filterOrFail(
         self(request),
         (response) => f(response.status),
@@ -327,7 +343,7 @@ export const map = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => B
   ) => Client.Client<R, E, B>
->(2, (self, f) => setProto((request) => Effect.map(self(request), f)))
+>(2, (self, f) => make((request) => Effect.map(self(request), f)))
 
 /** @internal */
 export const mapEffect = dual<
@@ -338,7 +354,7 @@ export const mapEffect = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, B>
   ) => Client.Client<R | R2, E | E2, B>
->(2, (self, f) => setProto((request) => Effect.flatMap(self(request), f)))
+>(2, (self, f) => make((request) => Effect.flatMap(self(request), f)))
 
 /** @internal */
 export const mapRequest = dual<
@@ -349,7 +365,7 @@ export const mapRequest = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => ClientRequest.ClientRequest
   ) => Client.Client<R, E, A>
->(2, (self, f) => setProto((request) => self(f(request))))
+>(2, (self, f) => make((request) => self(f(request))))
 
 /** @internal */
 export const mapRequestEffect = dual<
@@ -360,13 +376,13 @@ export const mapRequestEffect = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, ClientRequest.ClientRequest>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => setProto((request) => Effect.flatMap(f(request), self)))
+>(2, (self, f) => make((request) => Effect.flatMap(f(request), self)))
 
 /** @internal */
 export const withB3Propagation = <R, E>(
   self: Client.Client.WithResponse<R, E>
 ): Client.Client.WithResponse<R | Scope.Scope, E> =>
-  setProto((req) =>
+  make((req) =>
     pipe(
       Effect.map(
         Effect.currentSpan,
@@ -405,7 +421,7 @@ export const retry: {
   <R, E extends E0, E0, A, R1, B>(
     self: Client.Client<R, E, A>,
     policy: Schedule.Schedule<R1, E0, B>
-  ): Client.Client<R | R1, E, A> => setProto((request) => Effect.retry(self(request), policy))
+  ): Client.Client<R | R1, E, A> => make((request) => Effect.retry(self(request), policy))
 )
 
 /** @internal */
@@ -453,7 +469,7 @@ export const tap = dual<
     self: Client.Client<R, E, A>,
     f: (a: A) => Effect.Effect<R2, E2, _>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => setProto((request) => Effect.tap(self(request), f)))
+>(2, (self, f) => make((request) => Effect.tap(self(request), f)))
 
 /** @internal */
 export const tapRequest = dual<
@@ -464,4 +480,4 @@ export const tapRequest = dual<
     self: Client.Client<R, E, A>,
     f: (a: ClientRequest.ClientRequest) => Effect.Effect<R2, E2, _>
   ) => Client.Client<R | R2, E | E2, A>
->(2, (self, f) => setProto((request) => Effect.zipRight(f(request), self(request))))
+>(2, (self, f) => make((request) => Effect.zipRight(f(request), self(request))))

package/src/internal/http/clientError.ts

@@ -1,5 +1,5 @@
-import * as Data from "@effect/data/Data"
 import type * as Error from "@effect/platform/Http/ClientError"
+import * as Data from "effect/Data"
 
 /** @internal */
 export const TypeId: Error.TypeId = Symbol.for(

package/src/internal/http/clientRequest.ts

@@ -1,6 +1,3 @@
-import { dual } from "@effect/data/Function"
-import { pipeArguments } from "@effect/data/Pipeable"
-import * as Effect from "@effect/io/Effect"
 import type * as PlatformError from "@effect/platform/Error"
 import type * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
@@ -11,7 +8,10 @@ import type { Method } from "@effect/platform/Http/Method"
 import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalBody from "@effect/platform/internal/http/body"
 import type * as Schema from "@effect/schema/Schema"
-import type * as Stream from "@effect/stream/Stream"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import { pipeArguments } from "effect/Pipeable"
+import type * as Stream from "effect/Stream"
 
 /** @internal */
 export const TypeId: ClientRequest.TypeId = Symbol.for("@effect/platform/Http/ClientRequest") as ClientRequest.TypeId

package/src/internal/http/clientResponse.ts

@@ -1,5 +1,3 @@
-import * as Option from "@effect/data/Option"
-import * as Effect from "@effect/io/Effect"
 import type * as Error from "@effect/platform/Http/ClientError"
 import type * as ClientRequest from "@effect/platform/Http/ClientRequest"
 import type * as ClientResponse from "@effect/platform/Http/ClientResponse"
@@ -9,7 +7,9 @@ import * as UrlParams from "@effect/platform/Http/UrlParams"
 import * as internalError from "@effect/platform/internal/http/clientError"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
-import * as Stream from "@effect/stream/Stream"
+import * as Effect from "effect/Effect"
+import * as Option from "effect/Option"
+import * as Stream from "effect/Stream"
 
 /** @internal */
 export const TypeId: ClientResponse.TypeId = Symbol.for("@effect/platform/Http/ClientResponse") as ClientResponse.TypeId

package/src/internal/http/etag.ts

@@ -1,5 +1,5 @@
-import * as Context from "@effect/data/Context"
 import type * as Etag from "@effect/platform/Http/Etag"
+import * as Context from "effect/Context"
 
 /** @internal */
 export const GeneratorTypeId: Etag.GeneratorTypeId = Symbol.for(

package/src/internal/http/formData.ts

@@ -1,16 +1,16 @@
-import * as Chunk from "@effect/data/Chunk"
-import * as Data from "@effect/data/Data"
-import { dual, pipe } from "@effect/data/Function"
-import { globalValue } from "@effect/data/GlobalValue"
-import * as Option from "@effect/data/Option"
-import * as Predicate from "@effect/data/Predicate"
-import * as ReadonlyArray from "@effect/data/ReadonlyArray"
-import * as Effect from "@effect/io/Effect"
-import * as FiberRef from "@effect/io/FiberRef"
 import * as FileSystem from "@effect/platform/FileSystem"
 import type * as FormData from "@effect/platform/Http/FormData"
 import type * as ParseResult from "@effect/schema/ParseResult"
 import * as Schema from "@effect/schema/Schema"
+import * as Chunk from "effect/Chunk"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as FiberRef from "effect/FiberRef"
+import { dual, pipe } from "effect/Function"
+import { globalValue } from "effect/GlobalValue"
+import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
+import * as ReadonlyArray from "effect/ReadonlyArray"
 
 /** @internal */
 export const TypeId: FormData.TypeId = Symbol.for("@effect/platform/Http/FormData") as FormData.TypeId

package/src/internal/http/middleware.ts

@@ -1,10 +1,10 @@
-import { flow } from "@effect/data/Function"
-import * as Effect from "@effect/io/Effect"
 import * as Headers from "@effect/platform/Http/Headers"
 import * as IncomingMessage from "@effect/platform/Http/IncomingMessage"
 import type * as Middleware from "@effect/platform/Http/Middleware"
 import * as ServerRequest from "@effect/platform/Http/ServerRequest"
 import * as ServerResponse from "@effect/platform/Http/ServerResponse"
+import * as Effect from "effect/Effect"
+import { flow } from "effect/Function"
 
 /** @internal */
 export const make = <M extends Middleware.Middleware>(middleware: M): M => middleware

package/src/internal/http/platform.ts

@@ -1,11 +1,11 @@
-import * as Context from "@effect/data/Context"
-import { pipe } from "@effect/data/Function"
-import * as Effect from "@effect/io/Effect"
 import * as FileSystem from "@effect/platform/FileSystem"
 import type * as Body from "@effect/platform/Http/Body"
 import * as Etag from "@effect/platform/Http/Etag"
 import type * as Platform from "@effect/platform/Http/Platform"
 import type * as ServerResponse from "@effect/platform/Http/ServerResponse"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import { pipe } from "effect/Function"
 
 /** @internal */
 export const TypeId: Platform.TypeId = Symbol.for("@effect/platform/Http/Platform") as Platform.TypeId

package/src/internal/http/router.ts

@@ -1,13 +1,3 @@
-import * as Chunk from "@effect/data/Chunk"
-import * as Context from "@effect/data/Context"
-import * as Equal from "@effect/data/Equal"
-import { dual } from "@effect/data/Function"
-import * as Hash from "@effect/data/Hash"
-import * as Inspectable from "@effect/data/Inspectable"
-import * as Option from "@effect/data/Option"
-import { pipeArguments } from "@effect/data/Pipeable"
-import type * as Cause from "@effect/io/Cause"
-import * as Effect from "@effect/io/Effect"
 import type * as App from "@effect/platform/Http/App"
 import type * as Method from "@effect/platform/Http/Method"
 import type * as Router from "@effect/platform/Http/Router"
@@ -15,9 +5,14 @@ import * as Error from "@effect/platform/Http/ServerError"
 import * as ServerRequest from "@effect/platform/Http/ServerRequest"
 import type * as ServerResponse from "@effect/platform/Http/ServerResponse"
 import * as Schema from "@effect/schema/Schema"
-import * as Channel from "@effect/stream/Channel"
-import * as Sink from "@effect/stream/Sink"
-import * as Stream from "@effect/stream/Stream"
+import type * as Cause from "effect/Cause"
+import * as Chunk from "effect/Chunk"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import * as Effectable from "effect/Effectable"
+import { dual } from "effect/Function"
+import * as Inspectable from "effect/Inspectable"
+import * as Option from "effect/Option"
 import type { HTTPMethod } from "find-my-way"
 import FindMyWay from "find-my-way"
 
@@ -54,43 +49,27 @@ export const schemaParams = <I extends Readonly<Record<string, string>>, A>(sche
   )
 }
 
-class RouterImpl<R, E> implements Router.Router<R, E> {
+class RouterImpl<R, E> extends Effectable.Effectable<
+  Exclude<R, Router.RouteContext>,
+  E | Error.RouteNotFound,
+  ServerResponse.ServerResponse
+> implements Router.Router<R, E> {
   readonly [TypeId]: Router.TypeId
   constructor(
     readonly routes: Chunk.Chunk<Router.Route<R, E>>,
     readonly mounts: Chunk.Chunk<readonly [string, App.Default<R, E>]>
   ) {
+    super()
     this[TypeId] = TypeId
-    this[Effect.EffectTypeId] = undefined
-    this[Stream.StreamTypeId] = undefined
-    this[Sink.SinkTypeId] = undefined
-    this[Channel.ChannelTypeId] = undefined
   }
-  pipe() {
-    return pipeArguments(this, arguments)
-  }
-  private httpApp: App.Default<Router.Router.ExcludeProvided<R>, E | Error.RouteNotFound> | undefined
+  private httpApp:
+    | Effect.Effect<Exclude<R, Router.RouteContext>, E | Error.RouteNotFound, ServerResponse.ServerResponse>
+    | undefined
   commit() {
     if (this.httpApp === undefined) {
-      this.httpApp = toHttpApp(this)
+      this.httpApp = toHttpApp(this) as any
     }
-    return this.httpApp
-  }
-
-  // implements HttpApp/Effect
-  public _tag = "Commit" // OP_COMMIT
-  readonly [Effect.EffectTypeId]: any
-  readonly [Stream.StreamTypeId]: any
-  readonly [Sink.SinkTypeId]: any
-  readonly [Channel.ChannelTypeId]: any;
-  [Equal.symbol](
-    this: RouterImpl<R, E>,
-    that: RouterImpl<R, E>
-  ): boolean {
-    return this === that
-  }
-  [Hash.symbol](this: RouterImpl<R, E>): number {
-    return Hash.random(this)
+    return this.httpApp!
   }
   toJSON() {
     return {

package/src/internal/http/server.ts

@@ -1,12 +1,12 @@
-import * as Context from "@effect/data/Context"
-import { dual } from "@effect/data/Function"
-import * as Effect from "@effect/io/Effect"
-import type * as Scope from "@effect/io/Scope"
 import type * as App from "@effect/platform/Http/App"
 import type * as Middleware from "@effect/platform/Http/Middleware"
 import type * as Server from "@effect/platform/Http/Server"
 import type * as Error from "@effect/platform/Http/ServerError"
 import type * as ServerRequest from "@effect/platform/Http/ServerRequest"
+import * as Context from "effect/Context"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import type * as Scope from "effect/Scope"
 
 /** @internal */
 export const TypeId: Server.TypeId = Symbol.for("@effect/platform/Http/Server") as Server.TypeId

package/src/internal/http/serverError.ts

@@ -1,5 +1,5 @@
-import * as Data from "@effect/data/Data"
 import type * as Error from "@effect/platform/Http/ServerError"
+import * as Data from "effect/Data"
 
 /** @internal */
 export const TypeId: Error.TypeId = Symbol.for(