@effect/platform 0.46.2 → 0.47.0

package/src/Socket.ts

@@ -0,0 +1,291 @@
+/**
+ * @since 1.0.0
+ */
+import * as Cause from "effect/Cause"
+import * as Channel from "effect/Channel"
+import * as Chunk from "effect/Chunk"
+import * as Context from "effect/Context"
+import * as Data from "effect/Data"
+import * as Effect from "effect/Effect"
+import * as Exit from "effect/Exit"
+import * as FiberSet from "effect/FiberSet"
+import * as Layer from "effect/Layer"
+import * as Queue from "effect/Queue"
+import * as Scope from "effect/Scope"
+import type * as AsyncProducer from "effect/SingleProducerAsyncInput"
+import IsoWebSocket from "isomorphic-ws"
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export const SocketTypeId = Symbol.for("@effect/platform/Socket")
+
+/**
+ * @since 1.0.0
+ * @category type ids
+ */
+export type SocketTypeId = typeof SocketTypeId
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const Socket: Context.Tag<Socket, Socket> = Context.GenericTag<Socket>(
+  "@effect/platform/Socket"
+)
+
+/**
+ * @since 1.0.0
+ * @category models
+ */
+export interface Socket {
+  readonly [SocketTypeId]: SocketTypeId
+  readonly run: <R, E, _>(
+    handler: (_: Uint8Array) => Effect.Effect<_, E, R>
+  ) => Effect.Effect<void, SocketError | E, R>
+  readonly writer: Effect.Effect<(chunk: Uint8Array) => Effect.Effect<void>, never, Scope.Scope>
+}
+
+/**
+ * @since 1.0.0
+ * @category errors
+ */
+export class SocketError extends Data.TaggedError("SocketError")<{
+  readonly reason: "Write" | "Read" | "Open" | "Close"
+  readonly error: unknown
+}> {
+  /**
+   * @since 1.0.0
+   */
+  toString(): string {
+    return `SocketError: ${this.reason} - ${this.error}`
+  }
+}
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toChannel = <IE>(
+  self: Socket
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
+  Channel.unwrap(
+    Effect.gen(function*(_) {
+      const writeScope = yield* _(Scope.make())
+      const write = yield* _(Scope.extend(self.writer, writeScope))
+      const exitQueue = yield* _(Queue.unbounded<Exit.Exit<Chunk.Chunk<Uint8Array>, SocketError | IE>>())
+
+      const input: AsyncProducer.AsyncInputProducer<IE, Chunk.Chunk<Uint8Array>, unknown> = {
+        awaitRead: () => Effect.unit,
+        emit(chunk) {
+          return Effect.catchAllCause(
+            Effect.forEach(chunk, write, { discard: true }),
+            (cause) => Queue.offer(exitQueue, Exit.failCause(cause))
+          )
+        },
+        error(error) {
+          return Effect.zipRight(
+            Scope.close(writeScope, Exit.unit),
+            Queue.offer(exitQueue, Exit.failCause(error))
+          )
+        },
+        done() {
+          return Scope.close(writeScope, Exit.unit)
+        }
+      }
+
+      yield* _(
+        self.run((data) => Queue.offer(exitQueue, Exit.succeed(Chunk.of(data)))),
+        Effect.zipRight(Effect.failCause(Cause.empty)),
+        Effect.exit,
+        Effect.tap((exit) => Queue.offer(exitQueue, exit)),
+        Effect.fork
+      )
+
+      const loop: Channel.Channel<Chunk.Chunk<Uint8Array>, unknown, SocketError | IE, unknown, void, unknown> = Channel
+        .flatMap(
+          Queue.take(exitQueue),
+          Exit.match({
+            onFailure: (cause) => Cause.isEmptyType(cause) ? Channel.unit : Channel.failCause(cause),
+            onSuccess: (chunk) => Channel.zipRight(Channel.write(chunk), loop)
+          })
+        )
+
+      return Channel.embedInput(loop, input)
+    })
+  )
+
+/**
+ * @since 1.0.0
+ * @category combinators
+ */
+export const toChannelWith = <IE = never>() =>
+(
+  self: Socket
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
+  toChannel(self)
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeChannel = <IE = never>(): Channel.Channel<
+  Chunk.Chunk<Uint8Array>,
+  Chunk.Chunk<Uint8Array>,
+  SocketError | IE,
+  IE,
+  void,
+  unknown,
+  Socket
+> => Channel.unwrap(Effect.map(Socket, toChannelWith<IE>()))
+
+/**
+ * @since 1.0.0
+ */
+export const defaultCloseCodeIsError = (code: number) => code !== 1000 && code !== 1006
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export interface WebSocket {
+  readonly _: unique symbol
+}
+
+/**
+ * @since 1.0.0
+ * @category tags
+ */
+export const WebSocket: Context.Tag<WebSocket, globalThis.WebSocket> = Context.GenericTag(
+  "@effect/platform/Socket/WebSocket"
+)
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeWebSocket = (url: string | Effect.Effect<string>, options?: {
+  readonly closeCodeIsError?: (code: number) => boolean
+}): Effect.Effect<Socket> =>
+  fromWebSocket(
+    Effect.acquireRelease(
+      Effect.map(
+        typeof url === "string" ? Effect.succeed(url) : url,
+        (url) => {
+          const WS = "WebSocket" in globalThis ? globalThis.WebSocket : IsoWebSocket
+          return new WS(url) as globalThis.WebSocket
+        }
+      ),
+      (ws) => Effect.sync(() => ws.close())
+    ),
+    options
+  )
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const fromWebSocket = (
+  acquire: Effect.Effect<globalThis.WebSocket, SocketError, Scope.Scope>,
+  options?: {
+    readonly closeCodeIsError?: (code: number) => boolean
+  }
+): Effect.Effect<Socket> =>
+  Effect.gen(function*(_) {
+    const closeCodeIsError = options?.closeCodeIsError ?? defaultCloseCodeIsError
+    const sendQueue = yield* _(Queue.unbounded<Uint8Array>())
+
+    const run = <R, E, _>(handler: (_: Uint8Array) => Effect.Effect<_, E, R>) =>
+      Effect.gen(function*(_) {
+        const ws = yield* _(acquire)
+        const encoder = new TextEncoder()
+        const fiberSet = yield* _(FiberSet.make<any, E | SocketError>())
+        const run = yield* _(
+          FiberSet.runtime(fiberSet)<R>(),
+          Effect.provideService(WebSocket, ws)
+        )
+
+        ws.onmessage = (event) => {
+          run(
+            handler(
+              event.data instanceof Uint8Array
+                ? event.data
+                : typeof event.data === "string"
+                ? encoder.encode(event.data)
+                : new Uint8Array(event.data)
+            )
+          )
+        }
+
+        if (ws.readyState !== IsoWebSocket.OPEN) {
+          yield* _(Effect.async<void, SocketError, never>((resume) => {
+            ws.onopen = () => {
+              resume(Effect.unit)
+            }
+            ws.onerror = (error_) => {
+              resume(Effect.fail(new SocketError({ reason: "Open", error: (error_ as any).message })))
+            }
+          }))
+        }
+
+        yield* _(
+          Queue.take(sendQueue),
+          Effect.tap((chunk) =>
+            Effect.try({
+              try: () => ws.send(chunk),
+              catch: (error) => Effect.fail(new SocketError({ reason: "Write", error: (error as any).message }))
+            })
+          ),
+          Effect.forever,
+          Effect.fork
+        )
+
+        yield* _(
+          Effect.async<void, SocketError, never>((resume) => {
+            ws.onclose = (event) => {
+              if (closeCodeIsError(event.code)) {
+                resume(Effect.fail(new SocketError({ reason: "Close", error: event })))
+              } else {
+                resume(Effect.unit)
+              }
+            }
+            ws.onerror = (error) => {
+              resume(Effect.fail(new SocketError({ reason: "Read", error: (error as any).message })))
+            }
+          }),
+          Effect.raceFirst(FiberSet.join(fiberSet))
+        )
+      }).pipe(Effect.scoped)
+
+    const write = (chunk: Uint8Array) => Queue.offer(sendQueue, chunk)
+    const writer = Effect.succeed(write)
+
+    return Socket.of({
+      [SocketTypeId]: SocketTypeId,
+      run,
+      writer
+    })
+  })
+
+/**
+ * @since 1.0.0
+ * @category constructors
+ */
+export const makeWebSocketChannel = <IE = never>(
+  url: string,
+  options?: {
+    readonly closeCodeIsError?: (code: number) => boolean
+  }
+): Channel.Channel<Chunk.Chunk<Uint8Array>, Chunk.Chunk<Uint8Array>, SocketError | IE, IE, void, unknown> =>
+  Channel.unwrapScoped(
+    Effect.map(makeWebSocket(url, options), toChannelWith<IE>())
+  )
+
+/**
+ * @since 1.0.0
+ * @category layers
+ */
+export const layerWebSocket = (url: string, options?: {
+  readonly closeCodeIsError?: (code: number) => boolean
+}): Layer.Layer<Socket> => Layer.scoped(Socket, makeWebSocket(url, options))

package/src/index.ts

@@ -43,11 +43,21 @@ export * as KeyValueStore from "./KeyValueStore.js"
  */
 export * as Path from "./Path.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as PlatformLogger from "./PlatformLogger.js"
+
 /**
  * @since 1.0.0
  */
 export * as Runtime from "./Runtime.js"
 
+/**
+ * @since 1.0.0
+ */
+export * as Socket from "./Socket.js"
+
 /**
  * @since 1.0.0
  */

package/src/internal/http/router.ts

@@ -7,6 +7,7 @@ import * as Effectable from "effect/Effectable"
 import { dual } from "effect/Function"
 import * as Inspectable from "effect/Inspectable"
 import * as Option from "effect/Option"
+import * as Predicate from "effect/Predicate"
 import * as FindMyWay from "find-my-way-ts"
 import type * as App from "../../Http/App.js"
 import type * as Method from "../../Http/Method.js"
@@ -63,7 +64,9 @@ class RouterImpl<R, E> extends Effectable.StructuralClass<
   readonly [TypeId]: Router.TypeId
   constructor(
     readonly routes: Chunk.Chunk<Router.Route<R, E>>,
-    readonly mounts: Chunk.Chunk<readonly [string, App.Default<R, E>]>
+    readonly mounts: Chunk.Chunk<
+      readonly [prefix: string, httpApp: App.Default<R, E>, options?: { readonly includePrefix?: boolean } | undefined]
+    >
   ) {
     super()
     this[TypeId] = TypeId
@@ -95,9 +98,24 @@ class RouterImpl<R, E> extends Effectable.StructuralClass<
 
 const toHttpApp = <R, E>(
   self: Router.Router<R, E>
-): App.Default<Router.Router.ExcludeProvided<R>, E | Error.RouteNotFound> => {
+): App.Default<R, E | Error.RouteNotFound> => {
   const router = FindMyWay.make<Router.Route<R, E>>()
-  const mounts = Chunk.toReadonlyArray(self.mounts)
+  const mounts = Chunk.toReadonlyArray(self.mounts).map(([path, app, options]) =>
+    [
+      path,
+      new RouteContextImpl(
+        new RouteImpl(
+          "*",
+          options?.includePrefix ? `${path}/*` as Router.PathInput : "/*",
+          app,
+          options?.includePrefix ? Option.none() : Option.some(path)
+        ),
+        {},
+        {}
+      ),
+      options
+    ] as const
+  )
   const mountsLen = mounts.length
   Chunk.forEach(self.routes, (route) => {
     if (route.method === "*") {
@@ -108,16 +126,22 @@ const toHttpApp = <R, E>(
   })
   return Effect.flatMap(
     ServerRequest.ServerRequest,
-    (request): App.Default<Router.Router.ExcludeProvided<R>, E | Error.RouteNotFound> => {
+    (request): App.Default<R, E | Error.RouteNotFound> => {
       if (mountsLen > 0) {
         for (let i = 0; i < mountsLen; i++) {
-          const [path, app] = mounts[i]
+          const [path, context, options] = mounts[i]
           if (request.url.startsWith(path)) {
             return Effect.provideService(
-              app,
+              Effect.provideService(
+                context.route.handler as App.Default<R, E>,
+                RouteContext,
+                context
+              ),
               ServerRequest.ServerRequest,
-              sliceRequestUrl(request, path)
-            ) as App.Default<Router.Router.ExcludeProvided<R>, E>
+              options?.includePrefix ?
+                request :
+                sliceRequestUrl(request, path)
+            )
           }
         }
       }
@@ -247,19 +271,32 @@ export const mount = dual<
 export const mountApp = dual<
   <R1, E1>(
     path: `/${string}`,
-    that: App.Default<R1, E1>
+    that: App.Default<R1, E1>,
+    options?: {
+      readonly includePrefix?: boolean
+    }
   ) => <R, E>(
     self: Router.Router<R, E>
-  ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>,
+  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>,
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
     path: `/${string}`,
-    that: App.Default<R1, E1>
-  ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>
+    that: App.Default<R1, E1>,
+    options?: {
+      readonly includePrefix?: boolean
+    }
+  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>
 >(
-  3,
-  (self, path, that) =>
-    new RouterImpl<any, any>(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that]))
+  (args) => Predicate.hasProperty(args[0], TypeId),
+  <R, E, R1, E1>(
+    self: Router.Router<R, E>,
+    path: `/${string}`,
+    that: App.Default<R1, E1>,
+    options?: {
+      readonly includePrefix?: boolean
+    }
+  ): Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1> =>
+    new RouterImpl<any, any>(self.routes, Chunk.append(self.mounts, [removeTrailingSlash(path), that, options])) as any
 )
 
 /** @internal */
@@ -269,12 +306,12 @@ export const route = (method: Method.Method | "*"): {
     handler: Router.Route.Handler<R1, E1>
   ): <R, E>(
     self: Router.Router<R, E>
-  ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E1 | E>
+  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E1 | E>
   <R, E, R1, E1>(
     self: Router.Router<R, E>,
     path: Router.PathInput,
     handler: Router.Route.Handler<R1, E1>
-  ): Router.Router<Router.Router.ExcludeProvided<R | R1>, E1 | E>
+  ): Router.Router<R | Router.Router.ExcludeProvided<R1>, E1 | E>
 } =>
   dual<
     <R1, E1>(
@@ -282,12 +319,12 @@ export const route = (method: Method.Method | "*"): {
       handler: Router.Route.Handler<R1, E1>
     ) => <R, E>(
       self: Router.Router<R, E>
-    ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>,
+    ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>,
     <R, E, R1, E1>(
       self: Router.Router<R, E>,
       path: Router.PathInput,
       handler: Router.Route.Handler<R1, E1>
-    ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, E | E1>
+    ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, E | E1>
   >(3, (self, path, handler) =>
     new RouterImpl<any, any>(
       Chunk.append(self.routes, new RouteImpl(method, path, handler)),
@@ -343,22 +380,22 @@ export const use = dual<
 export const catchAll = dual<
   <E, R2, E2>(
     f: (e: E) => Router.Route.Handler<R2, E2>
-  ) => <R>(self: Router.Router<R, E>) => Router.Router<Router.Router.ExcludeProvided<R2 | R>, E2>,
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>,
   <R, E, R2, E2>(
     self: Router.Router<R, E>,
     f: (e: E) => Router.Route.Handler<R2, E2>
-  ) => Router.Router<Router.Router.ExcludeProvided<R2 | R>, E2>
+  ) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>
 >(2, (self, f) => use(self, Effect.catchAll(f)))
 
 /** @internal */
 export const catchAllCause = dual<
   <E, R2, E2>(
     f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
-  ) => <R>(self: Router.Router<R, E>) => Router.Router<Router.Router.ExcludeProvided<R2 | R>, E2>,
+  ) => <R>(self: Router.Router<R, E>) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>,
   <R, E, R2, E2>(
     self: Router.Router<R, E>,
     f: (e: Cause.Cause<E>) => Router.Route.Handler<R2, E2>
-  ) => Router.Router<Router.Router.ExcludeProvided<R2 | R>, E2>
+  ) => Router.Router<R | Router.Router.ExcludeProvided<R2>, E2>
 >(2, (self, f) => use(self, Effect.catchAllCause(f)))
 
 /** @internal */
@@ -368,12 +405,12 @@ export const catchTag = dual<
     f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
   ) => <R>(
     self: Router.Router<R, E>
-  ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, Exclude<E, { _tag: K }> | E1>,
+  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, Exclude<E, { _tag: K }> | E1>,
   <R, E, K extends (E extends { _tag: string } ? E["_tag"] : never), R1, E1>(
     self: Router.Router<R, E>,
     k: K,
     f: (e: Extract<E, { _tag: K }>) => Router.Route.Handler<R1, E1>
-  ) => Router.Router<Router.Router.ExcludeProvided<R | R1>, Exclude<E, { _tag: K }> | E1>
+  ) => Router.Router<R | Router.Router.ExcludeProvided<R1>, Exclude<E, { _tag: K }> | E1>
 >(3, (self, k, f) => use(self, Effect.catchTag(k, f)))
 
 /** @internal */
@@ -387,9 +424,9 @@ export const catchTags: {
   >(
     cases: Cases
   ): <R>(self: Router.Router<R, E>) => Router.Router<
-    Router.Router.ExcludeProvided<
-      | R
-      | {
+    | R
+    | Router.Router.ExcludeProvided<
+      {
         [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
       }[keyof Cases]
     >,
@@ -409,9 +446,9 @@ export const catchTags: {
     self: Router.Router<R, E>,
     cases: Cases
   ): Router.Router<
-    Router.Router.ExcludeProvided<
-      | R
-      | {
+    | R
+    | Router.Router.ExcludeProvided<
+      {
         [K in keyof Cases]: Cases[K] extends ((...args: Array<any>) => Effect.Effect<any, any, infer R>) ? R : never
       }[keyof Cases]
     >,
@@ -428,18 +465,17 @@ export const provideService = dual<
     service: Context.Tag.Service<T>
   ) => <R, E>(
     self: Router.Router<R, E>
-  ) => Router.Router<Router.Router.ExcludeProvided<Exclude<R, Context.Tag.Identifier<T>>>, E>,
+  ) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>,
   <R, E, T extends Context.Tag<any, any>>(
     self: Router.Router<R, E>,
     tag: T,
     service: Context.Tag.Service<T>
-  ) => Router.Router<Router.Router.ExcludeProvided<Exclude<R, Context.Tag.Identifier<T>>>, E>
+  ) => Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E>
 >(3, <R, E, T extends Context.Tag<any, any>>(
   self: Router.Router<R, E>,
   tag: T,
   service: Context.Tag.Service<T>
-): Router.Router<Router.Router.ExcludeProvided<Exclude<R, Context.Tag.Identifier<T>>>, E> =>
-  use(self, Effect.provideService(tag, service)))
+): Router.Router<Exclude<R, Context.Tag.Identifier<T>>, E> => use(self, Effect.provideService(tag, service)))
 
 /* @internal */
 export const provideServiceEffect = dual<
@@ -449,7 +485,10 @@ export const provideServiceEffect = dual<
   ) => <R, E>(
     self: Router.Router<R, E>
   ) => Router.Router<
-    Router.Router.ExcludeProvided<R1 | Exclude<R, Context.Tag.Identifier<T>>>,
+    Exclude<
+      R | Router.Router.ExcludeProvided<R1>,
+      Context.Tag.Identifier<T>
+    >,
     E | E1
   >,
   <R, E, T extends Context.Tag<any, any>, R1, E1>(
@@ -457,11 +496,20 @@ export const provideServiceEffect = dual<
     tag: T,
     effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
   ) => Router.Router<
-    Router.Router.ExcludeProvided<R1 | Exclude<R, Context.Tag.Identifier<T>>>,
+    Exclude<
+      R | Router.Router.ExcludeProvided<R1>,
+      Context.Tag.Identifier<T>
+    >,
     E | E1
   >
 >(3, <R, E, T extends Context.Tag<any, any>, R1, E1>(
   self: Router.Router<R, E>,
   tag: T,
   effect: Effect.Effect<Context.Tag.Service<T>, E1, R1>
-) => use(self, Effect.provideServiceEffect(tag, effect)))
+): Router.Router<
+  Exclude<
+    R | Router.Router.ExcludeProvided<R1>,
+    Context.Tag.Identifier<T>
+  >,
+  E | E1
+> => use(self, Effect.provideServiceEffect(tag, effect)) as any)

package/src/internal/http/serverRequest.ts

@@ -1,5 +1,6 @@
 import type * as ParseResult from "@effect/schema/ParseResult"
 import type * as Schema from "@effect/schema/Schema"
+import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Effect from "effect/Effect"
 import * as Option from "effect/Option"
@@ -14,6 +15,7 @@ import * as Error from "../../Http/ServerError.js"
 import type * as ServerRequest from "../../Http/ServerRequest.js"
 import * as UrlParams from "../../Http/UrlParams.js"
 import type * as Path from "../../Path.js"
+import * as Socket from "../../Socket.js"
 
 /** @internal */
 export const TypeId: ServerRequest.TypeId = Symbol.for("@effect/platform/Http/ServerRequest") as ServerRequest.TypeId
@@ -21,6 +23,12 @@ export const TypeId: ServerRequest.TypeId = Symbol.for("@effect/platform/Http/Se
 /** @internal */
 export const serverRequestTag = Context.GenericTag<ServerRequest.ServerRequest>("@effect/platform/Http/ServerRequest")
 
+/** @internal */
+export const upgrade = Effect.flatMap(serverRequestTag, (request) => request.upgrade)
+
+/** @internal */
+export const upgradeChannel = <IE = never>() => Channel.unwrap(Effect.map(upgrade, Socket.toChannelWith<IE>()))
+
 /** @internal */
 export const multipartPersisted = Effect.flatMap(serverRequestTag, (request) => request.multipart)
 
@@ -252,4 +260,12 @@ class ServerRequestImpl implements ServerRequest.ServerRequest {
     ))
     return this.arrayBufferEffect
   }
+
+  get upgrade(): Effect.Effect<Socket.Socket, Error.RequestError> {
+    return Effect.fail(Error.RequestError({
+      request: this,
+      reason: "Decode",
+      error: "Not an upgradeable ServerRequest"
+    }))
+  }
 }

package/src/internal/platformLogger.ts

@@ -0,0 +1,42 @@
+/**
+ * @since 1.0.0
+ */
+import type { DurationInput } from "effect/Duration"
+import * as Effect from "effect/Effect"
+import { dual } from "effect/Function"
+import * as Logger from "effect/Logger"
+import type * as Scope from "effect/Scope"
+import type { PlatformError } from "../Error.js"
+import * as FileSystem from "../FileSystem.js"
+
+/** @internal */
+export const toFile = dual<
+  (
+    path: string,
+    options?: FileSystem.OpenFileOptions & {
+      readonly batchWindow?: DurationInput
+    }
+  ) => <Message>(
+    self: Logger.Logger<Message, string>
+  ) => Effect.Effect<Logger.Logger<Message, void>, PlatformError, Scope.Scope | FileSystem.FileSystem>,
+  <Message>(
+    self: Logger.Logger<Message, string>,
+    path: string,
+    options?: FileSystem.OpenFileOptions & {
+      readonly batchWindow?: DurationInput
+    }
+  ) => Effect.Effect<Logger.Logger<Message, void>, PlatformError, Scope.Scope | FileSystem.FileSystem>
+>(
+  (args) => Logger.isLogger(args[0]),
+  (self, path, options) =>
+    Effect.gen(function*(_) {
+      const fs = yield* _(FileSystem.FileSystem)
+      const logFile = yield* _(fs.open(path, { flag: "a+", ...options }))
+      const encoder = new TextEncoder()
+      return yield* _(Logger.batched(
+        self,
+        options?.batchWindow ?? 1000,
+        (output) => Effect.ignore(logFile.write(encoder.encode(output.join("\n") + "\n")))
+      ))
+    })
+)

package/src/internal/worker.ts

@@ -405,7 +405,11 @@ export const makePoolSerialized = <I extends Schema.TaggedRequest.Any>(
       makeSerialized<I>(options),
       Effect.tap((worker) => Effect.sync(() => workers.add(worker))),
       Effect.tap((worker) => Effect.addFinalizer(() => Effect.sync(() => workers.delete(worker)))),
-      options.onCreate ? Effect.tap(options.onCreate) : identity,
+      options.onCreate
+        ? Effect.tap(
+          options.onCreate as (worker: Worker.SerializedWorker<I>) => Effect.Effect<void, WorkerError>
+        )
+        : identity,
       Effect.provideService(WorkerManager, manager)
     )
     const backing = yield* _(