@effect/platform 0.43.10 → 0.44.0

package/src/internal/http/serverResponse.ts

@@ -15,7 +15,7 @@ import * as internalBody from "./body.js"
 /** @internal */
 export const TypeId: ServerResponse.TypeId = Symbol.for("@effect/platform/Http/ServerResponse") as ServerResponse.TypeId
 
-class ServerResponseImpl extends Effectable.StructuralClass<never, never, ServerResponse.ServerResponse>
+class ServerResponseImpl extends Effectable.StructuralClass<ServerResponse.ServerResponse>
   implements ServerResponse.ServerResponse
 {
   readonly [TypeId]: ServerResponse.TypeId
@@ -42,7 +42,7 @@ class ServerResponseImpl extends Effectable.StructuralClass<never, never, Server
     }
   }
 
-  commit(): Effect.Effect<never, never, ServerResponse.ServerResponse> {
+  commit(): Effect.Effect<ServerResponse.ServerResponse> {
     return Effect.succeed(this)
   }
 
@@ -95,7 +95,7 @@ export const text = (body: string, options?: ServerResponse.Options.WithContentT
 export const json = (
   body: unknown,
   options?: ServerResponse.Options.WithContent
-): Effect.Effect<never, Body.BodyError, ServerResponse.ServerResponse> =>
+): Effect.Effect<ServerResponse.ServerResponse, Body.BodyError> =>
   Effect.map(internalBody.json(body), (body) =>
     new ServerResponseImpl(
       options?.status ?? 200,
@@ -117,14 +117,14 @@ export const unsafeJson = (
   )
 
 /** @internal */
-export const schemaJson = <R, I, A>(
-  schema: Schema.Schema<R, I, A>
+export const schemaJson = <A, I, R>(
+  schema: Schema.Schema<A, I, R>
 ) => {
   const encode = internalBody.jsonSchema(schema)
   return (
     body: A,
     options?: ServerResponse.Options.WithContent
-  ): Effect.Effect<R, Body.BodyError, ServerResponse.ServerResponse> =>
+  ): Effect.Effect<ServerResponse.ServerResponse, Body.BodyError, R> =>
     Effect.map(encode(body), (body) =>
       new ServerResponseImpl(
         options?.status ?? 200,
@@ -138,7 +138,7 @@ export const schemaJson = <R, I, A>(
 export const file = (
   path: string,
   options?: ServerResponse.Options & FileSystem.StreamOptions
-): Effect.Effect<Platform.Platform, PlatformError.PlatformError, ServerResponse.ServerResponse> =>
+): Effect.Effect<ServerResponse.ServerResponse, PlatformError.PlatformError, Platform.Platform> =>
   Effect.flatMap(
     Platform.Platform,
     (platform) => platform.fileResponse(path, options)
@@ -148,7 +148,7 @@ export const file = (
 export const fileWeb = (
   file: Body.Body.FileLike,
   options?: ServerResponse.Options.WithContent & FileSystem.StreamOptions
-): Effect.Effect<Platform.Platform, never, ServerResponse.ServerResponse> =>
+): Effect.Effect<ServerResponse.ServerResponse, never, Platform.Platform> =>
   Effect.flatMap(
     Platform.Platform,
     (platform) => platform.fileWebResponse(file, options)
@@ -189,7 +189,7 @@ export const formData = (
 
 /** @internal */
 export const stream = (
-  body: Stream.Stream<never, unknown, Uint8Array>,
+  body: Stream.Stream<Uint8Array, unknown>,
   options?: ServerResponse.Options
 ): ServerResponse.ServerResponse =>
   new ServerResponseImpl(
@@ -268,7 +268,7 @@ export const toWeb = (response: ServerResponse.ServerResponse, withoutBody = fal
   if (withoutBody) {
     return new Response(undefined, {
       status: response.status,
-      statusText: response.statusText,
+      statusText: response.statusText as string,
       headers: response.headers
     })
   }
@@ -277,7 +277,7 @@ export const toWeb = (response: ServerResponse.ServerResponse, withoutBody = fal
     case "Empty": {
       return new Response(undefined, {
         status: response.status,
-        statusText: response.statusText,
+        statusText: response.statusText as string,
         headers: response.headers
       })
     }

package/src/internal/keyValueStore.ts

@@ -14,7 +14,7 @@ export const TypeId: KeyValueStore.TypeId = Symbol.for(
 ) as KeyValueStore.TypeId
 
 /** @internal */
-export const keyValueStoreTag = Context.Tag<KeyValueStore.KeyValueStore>(TypeId)
+export const keyValueStoreTag = Context.GenericTag<KeyValueStore.KeyValueStore>("@effect/platform/KeyValueStore")
 
 /** @internal */
 export const make: (
@@ -68,9 +68,9 @@ export const SchemaStoreTypeId: KeyValueStore.SchemaStoreTypeId = Symbol.for(
 ) as KeyValueStore.SchemaStoreTypeId
 
 /** @internal */
-const makeSchemaStore = <R, I, A>(
+const makeSchemaStore = <A, I, R>(
   store: KeyValueStore.KeyValueStore,
-  schema: Schema.Schema<R, I, A>
+  schema: Schema.Schema<A, I, R>
 ): KeyValueStore.SchemaStore<R, A> => {
   const jsonSchema = Schema.parseJson(schema)
   const parse = Schema.decodeUnknown(jsonSchema)
@@ -166,11 +166,11 @@ export const layerFileSystem = (directory: string) =>
   )
 
 /** @internal */
-export const layerSchema = <R, I, A>(
-  schema: Schema.Schema<R, I, A>,
-  tagIdentifier?: unknown
+export const layerSchema = <A, I, R>(
+  schema: Schema.Schema<A, I, R>,
+  tagIdentifier: string
 ) => {
-  const tag = Context.Tag<KeyValueStore.SchemaStore<R, A>>(tagIdentifier)
+  const tag = Context.GenericTag<KeyValueStore.SchemaStore<R, A>>(tagIdentifier)
   const layer = Layer.effect(tag, Effect.map(keyValueStoreTag, (store) => store.forSchema(schema)))
   return { tag, layer } as const
 }

package/src/internal/path.ts

@@ -1,13 +1,13 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import * as Effect from "effect/Effect"
 import { identity } from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as PathB from "path-browserify"
+import PathB from "path-browserify"
 import { BadArgument } from "../Error.js"
 import type { Path as _Path } from "../Path.js"
 
 /** @internal */
-export const Path = Tag<_Path>("@effect/platform/Path")
+export const Path = GenericTag<_Path>("@effect/platform/Path")
 
 /** @internal */
 export const layer = Layer.succeed(
@@ -28,7 +28,7 @@ export const layer = Layer.succeed(
  * - MIT
  */
 
-function fromFileUrl(url: URL): Effect.Effect<never, BadArgument, string> {
+function fromFileUrl(url: URL): Effect.Effect<string, BadArgument> {
   if (url.protocol !== "file:") {
     return Effect.fail(BadArgument({
       module: "Path",

package/src/internal/terminal.ts

@@ -1,5 +1,5 @@
-import { Tag } from "effect/Context"
+import { GenericTag } from "effect/Context"
 import type * as Terminal from "../Terminal.js"
 
 /** @internal */
-export const tag = Tag<Terminal.Terminal>("@effect/platform/Terminal")
+export const tag = GenericTag<Terminal.Terminal>("@effect/platform/Terminal")

package/src/internal/worker.ts

@@ -39,8 +39,8 @@ export const PlatformWorkerTypeId: Worker.PlatformWorkerTypeId = Symbol.for(
 ) as Worker.PlatformWorkerTypeId
 
 /** @internal */
-export const PlatformWorker = Context.Tag<Worker.PlatformWorker>(
-  PlatformWorkerTypeId
+export const PlatformWorker = Context.GenericTag<Worker.PlatformWorker>(
+  "@effect/platform/Worker/PlatformWorker"
 )
 
 /** @internal */
@@ -49,8 +49,13 @@ export const WorkerManagerTypeId: Worker.WorkerManagerTypeId = Symbol.for(
 ) as Worker.WorkerManagerTypeId
 
 /** @internal */
-export const WorkerManager = Context.Tag<Worker.WorkerManager>(
-  WorkerManagerTypeId
+export const WorkerManager = Context.GenericTag<Worker.WorkerManager>(
+  "@effect/platform/Worker/WorkerManager"
+)
+
+/** @internal */
+export const Spawner = Context.GenericTag<Worker.Spawner, Worker.SpawnerFn>(
+  "@effect/platform/Worker/Spawner"
 )
 
 /** @internal */
@@ -64,28 +69,37 @@ export const makeManager = Effect.gen(function*(_) {
       initialMessage,
       permits = 1,
       queue,
-      spawn,
       transfers = (_) => []
     }: Worker.Worker.Options<I>) {
       return Effect.gen(function*(_) {
+        const spawn = yield* _(Spawner)
         const id = idCounter++
         let requestIdCounter = 0
         const semaphore = yield* _(Effect.makeSemaphore(permits))
         const requestMap = new Map<
           number,
-          readonly [Queue.Queue<Exit.Exit<E | WorkerError, ReadonlyArray<O>>>, Deferred.Deferred<never, void>]
+          readonly [Queue.Queue<Exit.Exit<ReadonlyArray<O>, E | WorkerError>>, Deferred.Deferred<void>]
         >()
         const sendQueue = yield* _(Effect.acquireRelease(
           Queue.unbounded<readonly [message: Worker.Worker.Request, transfers?: ReadonlyArray<unknown>]>(),
           Queue.shutdown
         ))
 
+        const collector = Transferable.unsafeMakeCollector()
+        const wrappedEncode = encode ?
+          ((message: I) =>
+            Effect.zipRight(
+              collector.clear,
+              Effect.provideService(encode(message), Transferable.Collector, collector)
+            )) :
+          Effect.succeed
+
         const outbound = queue ?? (yield* _(defaultQueue<I>()))
         yield* _(Effect.addFinalizer(() => outbound.shutdown))
 
         yield* _(
           Effect.gen(function*(_) {
-            const readyLatch = yield* _(Deferred.make<never, void>())
+            const readyLatch = yield* _(Deferred.make<void>())
             const backing = yield* _(
               platform.spawn<Worker.Worker.Request, Worker.Worker.Response<E, O>>(spawn(id))
             )
@@ -172,8 +186,8 @@ export const makeManager = Effect.gen(function*(_) {
           Effect.tap(
             Effect.all([
               Effect.sync(() => requestIdCounter++),
-              Queue.unbounded<Exit.Exit<E | WorkerError, ReadonlyArray<O>>>(),
-              Deferred.make<never, void>(),
+              Queue.unbounded<Exit.Exit<ReadonlyArray<O>, E | WorkerError>>(),
+              Deferred.make<void>(),
               Effect.map(
                 Effect.serviceOption(Tracer.ParentSpan),
                 Option.filter((span): span is Tracer.Span => span._tag === "Span")
@@ -189,8 +203,8 @@ export const makeManager = Effect.gen(function*(_) {
         const executeRelease = (
           [id, , deferred]: [
             number,
-            Queue.Queue<Exit.Exit<E | WorkerError, ReadonlyArray<O>>>,
-            Deferred.Deferred<never, void>,
+            Queue.Queue<Exit.Exit<ReadonlyArray<O>, E | WorkerError>>,
+            Deferred.Deferred<void>,
             Option.Option<Tracer.Span>
           ],
           exit: Exit.Exit<unknown, unknown>
@@ -211,8 +225,8 @@ export const makeManager = Effect.gen(function*(_) {
               executeRelease
             ),
             ([, queue]) => {
-              const loop: Channel.Channel<never, unknown, unknown, unknown, E | WorkerError, Chunk.Chunk<O>, void> =
-                Channel.flatMap(
+              const loop: Channel.Channel<Chunk.Chunk<O>, unknown, E | WorkerError, unknown, void, unknown> = Channel
+                .flatMap(
                   Queue.take(queue),
                   Exit.match({
                     onFailure: (cause) => Cause.isEmpty(cause) ? Channel.unit : Channel.failCause(cause),
@@ -244,8 +258,12 @@ export const makeManager = Effect.gen(function*(_) {
                 )
                 return pipe(
                   Effect.flatMap(
-                    encode ? encode(request) : Effect.succeed(request),
-                    (payload) => sendQueue.offer([[id, 0, payload, spanTuple], transferables])
+                    wrappedEncode(request),
+                    (payload) =>
+                      sendQueue.offer([[id, 0, payload, spanTuple], [
+                        ...transferables,
+                        ...collector.unsafeRead()
+                      ]])
                   ),
                   Effect.catchAllCause((cause) => Queue.offer(result[0], Exit.failCause(cause))),
                   Effect.zipRight(Deferred.await(result[1]))
@@ -278,9 +296,8 @@ export const makeManager = Effect.gen(function*(_) {
 export const layerManager = Layer.effect(WorkerManager, makeManager)
 
 /** @internal */
-export const makePool = <W>() =>
-<I, E, O>(
-  options: Worker.WorkerPool.Options<I, W>
+export const makePool = <I, E, O>(
+  options: Worker.WorkerPool.Options<I>
 ) =>
   Effect.gen(function*(_) {
     const manager = yield* _(WorkerManager)
@@ -329,27 +346,22 @@ export const makePool = <W>() =>
   })
 
 /** @internal */
-export const makePoolLayer = <W>(managerLayer: Layer.Layer<never, never, Worker.WorkerManager>) =>
-<Tag, I, E, O>(
+export const makePoolLayer = <Tag, I, E, O>(
   tag: Context.Tag<Tag, Worker.WorkerPool<I, E, O>>,
-  options: Worker.WorkerPool.Options<I, W>
-) => Layer.scoped(tag, makePool<W>()(options)).pipe(Layer.provide(managerLayer))
+  options: Worker.WorkerPool.Options<I>
+) => Layer.scoped(tag, makePool(options))
 
 /** @internal */
 export const makeSerialized = <
-  I extends Schema.TaggedRequest.Any,
-  W = unknown
+  I extends Schema.TaggedRequest.Any
 >(
-  options: Worker.SerializedWorker.Options<I, W>
-): Effect.Effect<Worker.WorkerManager | Scope.Scope, WorkerError, Worker.SerializedWorker<I>> =>
+  options: Worker.SerializedWorker.Options<I>
+): Effect.Effect<Worker.SerializedWorker<I>, WorkerError, Worker.WorkerManager | Worker.Spawner | Scope.Scope> =>
   Effect.gen(function*(_) {
     const manager = yield* _(WorkerManager)
     const backing = yield* _(
       manager.spawn({
         ...options as any,
-        transfers(message) {
-          return Transferable.get(message)
-        },
         encode(message) {
           return Effect.mapError(Serializable.serialize(message as any), (error) => WorkerError("encode", error))
         }
@@ -380,15 +392,14 @@ export const makeSerialized = <
   })
 
 /** @internal */
-export const makePoolSerialized = <W>() =>
-<I extends Schema.TaggedRequest.Any>(
-  options: Worker.SerializedWorkerPool.Options<I, W>
+export const makePoolSerialized = <I extends Schema.TaggedRequest.Any>(
+  options: Worker.SerializedWorkerPool.Options<I>
 ) =>
   Effect.gen(function*(_) {
     const manager = yield* _(WorkerManager)
     const workers = new Set<Worker.SerializedWorker<I>>()
     const acquire = pipe(
-      makeSerialized<I, W>(options),
+      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,
@@ -432,9 +443,14 @@ export const makePoolSerialized = <W>() =>
   })
 
 /** @internal */
-export const makePoolSerializedLayer =
-  <W>(managerLayer: Layer.Layer<never, never, Worker.WorkerManager>) =>
-  <Tag, I extends Schema.TaggedRequest.Any>(
-    tag: Context.Tag<Tag, Worker.SerializedWorkerPool<I>>,
-    options: Worker.SerializedWorkerPool.Options<I, W>
-  ) => Layer.scoped(tag, makePoolSerialized<W>()(options)).pipe(Layer.provide(managerLayer))
+export const makePoolSerializedLayer = <Tag, I extends Schema.TaggedRequest.Any>(
+  tag: Context.Tag<Tag, Worker.SerializedWorkerPool<I>>,
+  options: Worker.SerializedWorkerPool.Options<I>
+) => Layer.scoped(tag, makePoolSerialized(options))
+
+/** @internal */
+export const layerSpawner = <W = unknown>(spawner: Worker.SpawnerFn<W>) =>
+  Layer.succeed(
+    Spawner,
+    spawner
+  )

package/src/internal/workerError.ts

@@ -10,7 +10,7 @@ export const WorkerErrorTypeId: WorkerError_.WorkerErrorTypeId = Symbol.for(
 export const WorkerError = (
   reason: WorkerError_.WorkerError["reason"],
   error: unknown,
-  stack?: string
+  stack?: string | undefined
 ): WorkerError_.WorkerError =>
   Data.struct({
     [WorkerErrorTypeId]: WorkerErrorTypeId,

package/src/internal/workerRunner.ts

@@ -25,13 +25,13 @@ export const PlatformRunnerTypeId: WorkerRunner.PlatformRunnerTypeId = Symbol.fo
 ) as WorkerRunner.PlatformRunnerTypeId
 
 /** @internal */
-export const PlatformRunner = Context.Tag<WorkerRunner.PlatformRunner>(
-  PlatformRunnerTypeId
+export const PlatformRunner = Context.GenericTag<WorkerRunner.PlatformRunner>(
+  "@effect/platform/Runner/PlatformRunner"
 )
 
 /** @internal */
 export const make = <I, R, E, O>(
-  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: WorkerRunner.Runner.Options<I, E, O>
 ) =>
   Effect.gen(function*(_) {
@@ -46,12 +46,12 @@ export const make = <I, R, E, O>(
       platform.start<Worker.Worker.Request<I>, Worker.Worker.Response<E>>(shutdown),
       Scope.extend(scope)
     )
-    const fiberMap = new Map<number, Fiber.Fiber<never, void>>()
+    const fiberMap = new Map<number, Fiber.Fiber<void>>()
 
     yield* _(
       Queue.take(backing.queue),
       options?.decode ?
-        Effect.flatMap((req): Effect.Effect<never, WorkerError.WorkerError, Worker.Worker.Request<I>> => {
+        Effect.flatMap((req): Effect.Effect<Worker.Worker.Request<I>, WorkerError.WorkerError> => {
           if (req[1] === 1) {
             return Effect.succeed(req)
           }
@@ -68,26 +68,41 @@ export const make = <I, R, E, O>(
         }
 
         const stream = process(req[2])
+        const collector = Transferable.unsafeMakeCollector()
 
         let effect = Effect.isEffect(stream) ?
           Effect.matchCauseEffect(stream, {
             onFailure: (cause) =>
               Either.match(Cause.failureOrCause(cause), {
                 onLeft: (error) => {
-                  const transfers = options?.transfers ? options.transfers(error) : undefined
+                  const transfers = options?.transfers ? options.transfers(error) : []
                   return pipe(
-                    options?.encodeError ? options.encodeError(req[2], error) : Effect.succeed(error),
-                    Effect.flatMap((payload) => backing.send([id, 2, payload as any], transfers)),
+                    options?.encodeError
+                      ? Effect.provideService(options.encodeError(req[2], error), Transferable.Collector, collector)
+                      : Effect.succeed(error),
+                    Effect.flatMap((payload) =>
+                      backing.send([id, 2, payload as any], [
+                        ...transfers,
+                        ...collector.unsafeRead()
+                      ])
+                    ),
                     Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
                   )
                 },
                 onRight: (cause) => backing.send([id, 3, Cause.squash(cause)])
               }),
             onSuccess: (data) => {
-              const transfers = options?.transfers ? options.transfers(data) : undefined
+              const transfers = options?.transfers ? options.transfers(data) : []
               return pipe(
-                options?.encodeOutput ? options.encodeOutput(req[2], data) : Effect.succeed(data),
-                Effect.flatMap((payload) => backing.send([id, 0, [payload]], transfers)),
+                options?.encodeOutput
+                  ? Effect.provideService(options.encodeOutput(req[2], data), Transferable.Collector, collector)
+                  : Effect.succeed(data),
+                Effect.flatMap((payload) =>
+                  backing.send([id, 0, [payload]], [
+                    ...transfers,
+                    ...collector.unsafeRead()
+                  ])
+                ),
                 Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
               )
             }
@@ -103,7 +118,8 @@ export const make = <I, R, E, O>(
               }
 
               const transfers: Array<unknown> = []
-              return Effect.flatMap(
+              collector.unsafeClear()
+              return pipe(
                 Effect.forEach(data, (data) => {
                   if (options?.transfers) {
                     for (const option of options.transfers(data)) {
@@ -112,7 +128,11 @@ export const make = <I, R, E, O>(
                   }
                   return Effect.orDie(options.encodeOutput!(req[2], data))
                 }),
-                (payload) => backing.send([id, 0, payload], transfers)
+                Effect.provideService(Transferable.Collector, collector),
+                Effect.flatMap((payload) => {
+                  collector.unsafeRead().forEach((transfer) => transfers.push(transfer))
+                  return backing.send([id, 0, payload], transfers)
+                })
               )
             }),
             Stream.runDrain,
@@ -120,10 +140,18 @@ export const make = <I, R, E, O>(
               onFailure: (cause) =>
                 Either.match(Cause.failureOrCause(cause), {
                   onLeft: (error) => {
-                    const transfers = options?.transfers ? options.transfers(error) : undefined
+                    const transfers = options?.transfers ? options.transfers(error) : []
+                    collector.unsafeClear()
                     return pipe(
-                      options?.encodeError ? options.encodeError(req[2], error) : Effect.succeed(error),
-                      Effect.flatMap((payload) => backing.send([id, 2, payload as any], transfers)),
+                      options?.encodeError
+                        ? Effect.provideService(options.encodeError(req[2], error), Transferable.Collector, collector)
+                        : Effect.succeed(error),
+                      Effect.flatMap((payload) =>
+                        backing.send([id, 2, payload as any], [
+                          ...transfers,
+                          ...collector.unsafeRead()
+                        ])
+                      ),
                       Effect.catchAllCause((cause) => backing.send([id, 3, Cause.squash(cause)]))
                     )
                   },
@@ -158,9 +186,9 @@ export const make = <I, R, E, O>(
 
 /** @internal */
 export const layer = <I, R, E, O>(
-  process: (request: I) => Stream.Stream<R, E, O> | Effect.Effect<R, E, O>,
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
   options?: WorkerRunner.Runner.Options<I, E, O>
-): Layer.Layer<WorkerRunner.PlatformRunner | R, WorkerError.WorkerError, never> =>
+): Layer.Layer<never, WorkerError.WorkerError, WorkerRunner.PlatformRunner | R> =>
   Layer.scopedDiscard(make(process, options))
 
 /** @internal */
@@ -170,20 +198,20 @@ export const makeSerialized = <
   A extends Schema.TaggedRequest.Any,
   const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<R, I, A>,
+  schema: Schema.Schema<A, I, R>,
   handlers: Handlers
 ): Effect.Effect<
+  void,
+  WorkerError.WorkerError,
   | R
   | WorkerRunner.PlatformRunner
   | Scope.Scope
-  | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
-  WorkerError.WorkerError,
-  void
+  | WorkerRunner.SerializedRunner.HandlersContext<Handlers>
 > =>
   Effect.gen(function*(_) {
     const scope = yield* _(Effect.scope)
     let context = Context.empty() as Context.Context<any>
-    const parseRequest = Schema.decodeUnknown(schema) as (_: unknown) => Effect.Effect<never, never, A>
+    const parseRequest = Schema.decodeUnknown(schema) as (_: unknown) => Effect.Effect<A>
 
     return yield* _(make((request: A) => {
       const result = (handlers as any)[request._tag](request)
@@ -197,9 +225,6 @@ export const makeSerialized = <
       }
       return Stream.provideContext(result as any, context)
     }, {
-      transfers(message) {
-        return Transferable.get(message)
-      },
       decode(message) {
         return Effect.mapError(
           parseRequest(message),
@@ -228,12 +253,12 @@ export const layerSerialized = <
   A extends Schema.TaggedRequest.Any,
   const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>
 >(
-  schema: Schema.Schema<R, I, A>,
+  schema: Schema.Schema<A, I, R>,
   handlers: Handlers
 ): Layer.Layer<
+  never,
+  WorkerError.WorkerError,
   | R
   | WorkerRunner.PlatformRunner
-  | WorkerRunner.SerializedRunner.HandlersContext<Handlers>,
-  WorkerError.WorkerError,
-  never
+  | WorkerRunner.SerializedRunner.HandlersContext<Handlers>
 > => Layer.scopedDiscard(makeSerialized(schema, handlers))