@effect/platform 0.40.1 → 0.40.3

package/src/Http/Multiplex.ts

@@ -0,0 +1,174 @@
+/**
+ * @since 1.0.0
+ */
+import type * as Effect from "effect/Effect"
+import * as internal from "../internal/http/multiplex.js"
+import type * as App from "./App.js"
+import type * as Error from "./ServerError.js"
+import type * as ServerRequest from "./ServerRequest.js"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const TypeId: unique symbol = internal.TypeId
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type TypeId = typeof TypeId
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Multiplex<R, E> extends App.Default<R, E | Error.RouteNotFound> {
+  readonly [TypeId]: TypeId
+  readonly apps: ReadonlyArray<
+    readonly [
+      predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>,
+      app: App.Default<R, E>
+    ]
+  >
+}
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const empty: Multiplex<never, never> = internal.empty
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const make: <R, E>(
+  apps: Iterable<
+    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>, app: App.Default<R, E>]
+  >
+) => Multiplex<R, E> = internal.make
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const add: {
+  <R2, E2, R3, E3>(
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    app: App.Default<R3, E3>
+  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R3 | R, E2 | E3 | E>
+  <R, E, R2, E2, R3, E3>(
+    self: Multiplex<R, E>,
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    app: App.Default<R3, E3>
+  ): Multiplex<R | R2 | R3, E | E2 | E3>
+} = internal.add
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const headerExact: {
+  <R2, E2>(
+    header: string,
+    value: string,
+    app: App.Default<R2, E2>
+  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(
+    self: Multiplex<R, E>,
+    header: string,
+    value: string,
+    app: App.Default<R2, E2>
+  ): Multiplex<R | R2, E | E2>
+} = internal.headerExact
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const headerRegex: {
+  <R2, E2>(
+    header: string,
+    regex: RegExp,
+    app: App.Default<R2, E2>
+  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(
+    self: Multiplex<R, E>,
+    header: string,
+    regex: RegExp,
+    app: App.Default<R2, E2>
+  ): Multiplex<R | R2, E | E2>
+} = internal.headerRegex
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const headerStartsWith: {
+  <R2, E2>(
+    header: string,
+    prefix: string,
+    app: App.Default<R2, E2>
+  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(
+    self: Multiplex<R, E>,
+    header: string,
+    prefix: string,
+    app: App.Default<R2, E2>
+  ): Multiplex<R | R2, E | E2>
+} = internal.headerStartsWith
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const headerEndsWith: {
+  <R2, E2>(
+    header: string,
+    suffix: string,
+    app: App.Default<R2, E2>
+  ): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(
+    self: Multiplex<R, E>,
+    header: string,
+    suffix: string,
+    app: App.Default<R2, E2>
+  ): Multiplex<R | R2, E | E2>
+} = internal.headerEndsWith
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const hostExact: {
+  <R2, E2>(host: string, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(self: Multiplex<R, E>, host: string, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+} = internal.hostExact
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const hostRegex: {
+  <R2, E2>(regex: RegExp, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(self: Multiplex<R, E>, regex: RegExp, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+} = internal.hostRegex
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const hostStartsWith: {
+  <R2, E2>(prefix: string, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(self: Multiplex<R, E>, prefix: string, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+} = internal.hostStartsWith
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const hostEndsWith: {
+  <R2, E2>(suffix: string, app: App.Default<R2, E2>): <R, E>(self: Multiplex<R, E>) => Multiplex<R2 | R, E2 | E>
+  <R, E, R2, E2>(self: Multiplex<R, E>, suffix: string, app: App.Default<R2, E2>): Multiplex<R | R2, E | E2>
+} = internal.hostEndsWith

package/src/HttpClient.ts

@@ -13,49 +13,49 @@ export {
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Body](https://effect-ts.github.io/platform/platform/Http/Body.ts.html)
+   * - Docs: [Http/Body](https://effect-ts.github.io/effect/platform/Http/Body.ts.html)
    * - Module: `@effect/platform/Http/Body`
    */
   body,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Client](https://effect-ts.github.io/platform/platform/Http/Client.ts.html)
+   * - Docs: [Http/Client](https://effect-ts.github.io/effect/platform/Http/Client.ts.html)
    * - Module: `@effect/platform/Http/Client`
    */
   client,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/ClientError](https://effect-ts.github.io/platform/platform/Http/ClientError.ts.html)
+   * - Docs: [Http/ClientError](https://effect-ts.github.io/effect/platform/Http/ClientError.ts.html)
    * - Module: `@effect/platform/Http/ClientError`
    */
   error,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Headers](https://effect-ts.github.io/platform/platform/Http/Headers.ts.html)
+   * - Docs: [Http/Headers](https://effect-ts.github.io/effect/platform/Http/Headers.ts.html)
    * - Module: `@effect/platform/Http/Headers`
    */
   headers,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/ClientRequest](https://effect-ts.github.io/platform/platform/Http/ClientRequest.ts.html)
+   * - Docs: [Http/ClientRequest](https://effect-ts.github.io/effect/platform/Http/ClientRequest.ts.html)
    * - Module: `@effect/platform/Http/ClientRequest`
    */
   request,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/ClientResponse](https://effect-ts.github.io/platform/platform/Http/ClientResponse.ts.html)
+   * - Docs: [Http/ClientResponse](https://effect-ts.github.io/effect/platform/Http/ClientResponse.ts.html)
    * - Module: `@effect/platform/Http/ClientResponse`
    */
   response,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/UrlParams](https://effect-ts.github.io/platform/platform/Http/UrlParams.ts.html)
+   * - Docs: [Http/UrlParams](https://effect-ts.github.io/effect/platform/Http/UrlParams.ts.html)
    * - Module: `@effect/platform/Http/UrlParams`
    */
   urlParams

package/src/HttpServer.ts

@@ -6,6 +6,7 @@ import * as body from "./Http/Body.js"
 import * as headers from "./Http/Headers.js"
 import * as middleware from "./Http/Middleware.js"
 import * as multipart from "./Http/Multipart.js"
+import * as multiplex from "./Http/Multiplex.js"
 import * as router from "./Http/Router.js"
 import * as error from "./Http/ServerError.js"
 import * as request from "./Http/ServerRequest.js"
@@ -16,70 +17,77 @@ export {
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/App](https://effect-ts.github.io/platform/platform/Http/App.html)
+   * - Docs: [Http/App](https://effect-ts.github.io/effect/platform/Http/App.ts.html)
    * - Module: `@effect/platform/Http/App`
    */
   app,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Body](https://effect-ts.github.io/platform/platform/Http/Body.html)
+   * - Docs: [Http/Body](https://effect-ts.github.io/effect/platform/Http/Body.ts.html)
    * - Module: `@effect/platform/Http/Body`
    */
   body,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/ServerError](https://effect-ts.github.io/platform/platform/Http/ServerError.html)
+   * - Docs: [Http/ServerError](https://effect-ts.github.io/effect/platform/Http/ServerError.ts.html)
    * - Module: `@effect/platform/Http/ServerError`
    */
   error,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Headers](https://effect-ts.github.io/platform/platform/Http/Headers.html)
+   * - Docs: [Http/Headers](https://effect-ts.github.io/effect/platform/Http/Headers.ts.html)
    * - Module: `@effect/platform/Http/Headers`
    */
   headers,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Middleware](https://effect-ts.github.io/platform/platform/Http/Middleware.html)
+   * - Docs: [Http/Middleware](https://effect-ts.github.io/effect/platform/Http/Middleware.ts.html)
    * - Module: `@effect/platform/Http/Middleware`
    */
   middleware,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Multipart](https://effect-ts.github.io/platform/platform/Http/Multipart.html)
+   * - Docs: [Http/Multipart](https://effect-ts.github.io/effect/platform/Http/Multipart.ts.html)
    * - Module: `@effect/platform/Http/Multipart`
    */
   multipart,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/ServerRequest](https://effect-ts.github.io/platform/platform/Http/ServerRequest.html)
+   * - Docs: [Http/Multiplex](https://effect-ts.github.io/effect/platform/Http/Multiplex.ts.html)
+   * - Module: `@effect/platform/Http/Multiplex`
+   */
+  multiplex,
+  /**
+   * @since 1.0.0
+   *
+   * - Docs: [Http/ServerRequest](https://effect-ts.github.io/effect/platform/Http/ServerRequest.ts.html)
    * - Module: `@effect/platform/Http/ServerRequest`
    */
   request,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/ServerResponse](https://effect-ts.github.io/platform/platform/Http/ServerResponse.html)
+   * - Docs: [Http/ServerResponse](https://effect-ts.github.io/effect/platform/Http/ServerResponse.ts.html)
    * - Module: `@effect/platform/Http/ServerResponse`
    */
   response,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/Router](https://effect-ts.github.io/platform/platform/Http/Router.html)
+   * - Docs: [Http/Router](https://effect-ts.github.io/effect/platform/Http/Router.ts.html)
    * - Module: `@effect/platform/Http/Router`
    */
   router,
   /**
    * @since 1.0.0
    *
-   * - Docs: [Http/UrlParams](https://effect-ts.github.io/platform/platform/Http/UrlParams.html)
+   * - Docs: [Http/UrlParams](https://effect-ts.github.io/effect/platform/Http/UrlParams.ts.html)
    * - Module: `@effect/platform/Http/UrlParams`
    */
   urlParams

package/src/Transferable.ts

@@ -43,21 +43,16 @@ export const get = (u: unknown): ReadonlyArray<globalThis.Transferable> => {
  * @category schema
  */
 export const schema: {
-  <A>(
-    f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A & Transferable>
-  <I, A>(
-    self: Schema.Schema<I, A>,
-    f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ): Schema.Schema<I, A & Transferable>
+  <A>(f: (_: A) => ReadonlyArray<globalThis.Transferable>): <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>
+  <I, A>(self: Schema.Schema<I, A>, f: (_: A) => ReadonlyArray<globalThis.Transferable>): Schema.Schema<I, A>
 } = dual<
   <A>(
     f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ) => <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A & Transferable>,
+  ) => <I>(self: Schema.Schema<I, A>) => Schema.Schema<I, A>,
   <I, A>(
     self: Schema.Schema<I, A>,
     f: (_: A) => ReadonlyArray<globalThis.Transferable>
-  ) => Schema.Schema<I, A & Transferable>
+  ) => Schema.Schema<I, A>
 >(2, <I, A>(
   self: Schema.Schema<I, A>,
   f: (_: A) => ReadonlyArray<globalThis.Transferable>
@@ -71,7 +66,7 @@ export const schema: {
         [symbol]() {
           return f(this as any)
         }
-      }) as A & Transferable,
+      }) as A,
     (output) => output as A
   ))
 
@@ -81,7 +76,7 @@ export const schema: {
  */
 export const schemaFromSelf = <I, A>(
   item: Schema.Schema<I, A>
-): Schema.Schema<I & Transferable, A & Transferable> => {
+): Schema.Schema<I, A> => {
   return Schema.declare(
     [item],
     item,

package/src/Worker.ts

@@ -10,10 +10,12 @@ import type * as Effect from "effect/Effect"
 import type * as Fiber from "effect/Fiber"
 import type { LazyArg } from "effect/Function"
 import type * as Layer from "effect/Layer"
+import type * as Option from "effect/Option"
 import type * as Pool from "effect/Pool"
 import type * as Queue from "effect/Queue"
 import type * as Scope from "effect/Scope"
 import type * as Stream from "effect/Stream"
+import type * as Tracer from "effect/Tracer"
 import * as internal from "./internal/worker.js"
 import type { WorkerError } from "./WorkerError.js"
 
@@ -98,7 +100,15 @@ export declare namespace Worker {
    * @since 1.0.0
    * @category models
    */
-  export type Request<I = unknown> = readonly [id: number, data: 0, I] | readonly [id: number, interrupt: 1]
+  export type Request<I = unknown> =
+    | readonly [id: number, data: 0, I, trace?: Span]
+    | readonly [id: number, interrupt: 1]
+
+  /**
+   * @since 1.0.0
+   * @category models
+   */
+  export type Span = readonly [traceId: string, spanId: string, sampled: boolean]
 
   /**
    * @since 1.0.0
@@ -150,8 +160,8 @@ export declare namespace WorkerPool {
  * @since 1.0.0
  */
 export interface WorkerQueue<I> {
-  readonly offer: (id: number, item: I) => Effect.Effect<never, never, void>
-  readonly take: Effect.Effect<never, never, readonly [id: number, item: I]>
+  readonly offer: (id: number, item: I, span: Option.Option<Tracer.Span>) => Effect.Effect<never, never, void>
+  readonly take: Effect.Effect<never, never, readonly [id: number, item: I, span: Option.Option<Tracer.Span>]>
   readonly shutdown: Effect.Effect<never, never, void>
 }
 

package/src/internal/http/multiplex.ts

@@ -0,0 +1,222 @@
+import * as Effect from "effect/Effect"
+import * as Effectable from "effect/Effectable"
+import { dual } from "effect/Function"
+import * as ReadonlyArray from "effect/ReadonlyArray"
+import type * as App from "../../Http/App.js"
+import type * as Multiplex from "../../Http/Multiplex.js"
+import * as Error from "../../Http/ServerError.js"
+import * as ServerRequest from "../../Http/ServerRequest.js"
+import type * as ServerResponse from "../../Http/ServerResponse.js"
+
+/** @internal */
+export const TypeId: Multiplex.TypeId = Symbol.for("@effect/platform/Http/Multiplex") as Multiplex.TypeId
+
+class MultiplexImpl<R, E>
+  extends Effectable.Class<R | ServerRequest.ServerRequest, E | Error.RouteNotFound, ServerResponse.ServerResponse>
+  implements Multiplex.Multiplex<R, E>
+{
+  readonly [TypeId]: Multiplex.TypeId
+
+  constructor(
+    readonly apps: ReadonlyArray<
+      readonly [
+        predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>,
+        app: App.Default<R, E>
+      ]
+    >
+  ) {
+    super()
+    this[TypeId] = TypeId
+
+    let execute: (request: ServerRequest.ServerRequest) => App.Default<R, E | Error.RouteNotFound> = (request) =>
+      Effect.fail(Error.RouteNotFound({ request }))
+
+    for (let i = apps.length - 1; i >= 0; i--) {
+      const [predicate, app] = apps[i]
+      const previous = execute
+      execute = (request) =>
+        Effect.flatMap(
+          predicate(request),
+          (match) => match ? app : previous(request)
+        )
+    }
+
+    this.execute = Effect.flatMap(ServerRequest.ServerRequest, execute)
+  }
+
+  execute: App.Default<R, E | Error.RouteNotFound>
+
+  commit() {
+    return this.execute
+  }
+}
+
+/** @internal */
+export const empty: Multiplex.Multiplex<never, never> = new MultiplexImpl([])
+
+/** @internal */
+export const make = <R, E>(
+  apps: Iterable<
+    readonly [predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R, E, boolean>, app: App.Default<R, E>]
+  >
+): Multiplex.Multiplex<R, E> => new MultiplexImpl(ReadonlyArray.fromIterable(apps))
+
+/** @internal */
+export const add = dual<
+  <R2, E2, R3, E3>(
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    app: App.Default<R3, E3>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2 | R3, E | E2 | E3>,
+  <R, E, R2, E2, R3, E3>(
+    self: Multiplex.Multiplex<R, E>,
+    predicate: (request: ServerRequest.ServerRequest) => Effect.Effect<R2, E2, boolean>,
+    app: App.Default<R3, E3>
+  ) => Multiplex.Multiplex<R | R2 | R3, E | E2 | E3>
+>(
+  3,
+  (self, predicate, app) =>
+    make([
+      ...self.apps,
+      [predicate, app]
+    ] as any)
+)
+
+/** @internal */
+export const headerExact = dual<
+  <R2, E2>(
+    header: string,
+    value: string,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    header: string,
+    value: string,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(
+  4,
+  (self, header, value, app) =>
+    add(self, (req) =>
+      req.headers[header] !== undefined
+        ? Effect.succeed(req.headers[header] === value)
+        : Effect.succeed(false), app)
+)
+
+/** @internal */
+export const headerRegex = dual<
+  <R2, E2>(
+    header: string,
+    regex: RegExp,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    header: string,
+    regex: RegExp,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(
+  4,
+  (self, header, regex, app) =>
+    add(self, (req) =>
+      req.headers[header] !== undefined
+        ? Effect.succeed(regex.test(req.headers[header]))
+        : Effect.succeed(false), app)
+)
+
+/** @internal */
+export const headerStartsWith = dual<
+  <R2, E2>(
+    header: string,
+    prefix: string,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    header: string,
+    prefix: string,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(
+  4,
+  (self, header, prefix, app) =>
+    add(self, (req) =>
+      req.headers[header] !== undefined
+        ? Effect.succeed(req.headers[header].startsWith(prefix))
+        : Effect.succeed(false), app)
+)
+
+/** @internal */
+export const headerEndsWith = dual<
+  <R2, E2>(
+    header: string,
+    suffix: string,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    header: string,
+    suffix: string,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(
+  4,
+  (self, header, suffix, app) =>
+    add(self, (req) =>
+      req.headers[header] !== undefined
+        ? Effect.succeed(req.headers[header].endsWith(suffix))
+        : Effect.succeed(false), app)
+)
+
+/** @internal */
+export const hostRegex = dual<
+  <R2, E2>(
+    regex: RegExp,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    regex: RegExp,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(3, (self, regex, app) => headerRegex(self, "host", regex, app))
+
+/** @internal */
+export const hostStartsWith = dual<
+  <R2, E2>(
+    prefix: string,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    prefix: string,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(3, (self, prefix, app) => headerStartsWith(self, "host", prefix, app))
+
+/** @internal */
+export const hostEndsWith = dual<
+  <R2, E2>(
+    suffix: string,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    suffix: string,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(3, (self, suffix, app) => headerEndsWith(self, "host", suffix, app))
+
+/** @internal */
+export const hostExact = dual<
+  <R2, E2>(
+    host: string,
+    app: App.Default<R2, E2>
+  ) => <R, E>(self: Multiplex.Multiplex<R, E>) => Multiplex.Multiplex<R | R2, E | E2>,
+  <R, E, R2, E2>(
+    self: Multiplex.Multiplex<R, E>,
+    host: string,
+    app: App.Default<R2, E2>
+  ) => Multiplex.Multiplex<R | R2, E | E2>
+>(3, (self, host, app) => headerExact(self, "host", host, app))

package/src/internal/http/router.ts

@@ -65,15 +65,15 @@ class RouterImpl<R, E> extends Effectable.StructuralClass<
   ) {
     super()
     this[TypeId] = TypeId
+    this.httpApp = toHttpApp(this) as any
   }
-  private httpApp:
-    | Effect.Effect<Exclude<R, Router.RouteContext>, E | Error.RouteNotFound, ServerResponse.ServerResponse>
-    | undefined
+  private httpApp: Effect.Effect<
+    Exclude<R, Router.RouteContext>,
+    E | Error.RouteNotFound,
+    ServerResponse.ServerResponse
+  >
   commit() {
-    if (this.httpApp === undefined) {
-      this.httpApp = toHttpApp(this) as any
-    }
-    return this.httpApp!
+    return this.httpApp
   }
   toJSON() {
     return {