@livestore/utils 0.0.54-dev.27 → 0.0.54-dev.28

package/src/effect/worker-tmp/internal/worker.ts

@@ -0,0 +1,415 @@
+/* eslint-disable prefer-arrow/prefer-arrow-functions */
+import { Transferable } from '@effect/platform'
+import * as Schema from '@effect/schema/Schema'
+import * as Serializable from '@effect/schema/Serializable'
+import * as Arr from 'effect/Array'
+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 Deferred from 'effect/Deferred'
+import * as Effect from 'effect/Effect'
+import * as Exit from 'effect/Exit'
+import * as Fiber from 'effect/Fiber'
+import { identity, pipe } from 'effect/Function'
+import * as Layer from 'effect/Layer'
+import * as Option from 'effect/Option'
+import * as Pool from 'effect/Pool'
+import * as Queue from 'effect/Queue'
+import * as Schedule from 'effect/Schedule'
+import type * as Scope from 'effect/Scope'
+import * as Stream from 'effect/Stream'
+import * as Tracer from 'effect/Tracer'
+
+import type * as Worker from '../Worker.js'
+import { WorkerError } from '../WorkerError.js'
+
+/** @internal */
+export const defaultQueue = <I>() =>
+  Effect.map(
+    Queue.unbounded<readonly [id: number, item: I, span: Option.Option<Tracer.Span>]>(),
+    (queue): Worker.WorkerQueue<I> => ({
+      offer: (id, item, span) => Queue.offer(queue, [id, item, span]),
+      take: Queue.take(queue),
+      shutdown: Queue.shutdown(queue),
+    }),
+  )
+
+/** @internal */
+export const PlatformWorkerTypeId: Worker.PlatformWorkerTypeId = Symbol.for(
+  '@effect/platform/Worker/PlatformWorker',
+) as Worker.PlatformWorkerTypeId
+
+/** @internal */
+export const PlatformWorker = Context.GenericTag<Worker.PlatformWorker>('@effect/platform/Worker/PlatformWorker')
+
+/** @internal */
+export const WorkerManagerTypeId: Worker.WorkerManagerTypeId = Symbol.for(
+  '@effect/platform/Worker/WorkerManager',
+) as Worker.WorkerManagerTypeId
+
+/** @internal */
+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 */
+export const makeManager = Effect.gen(function* () {
+  const platform = yield* PlatformWorker
+  let idCounter = 0
+  return WorkerManager.of({
+    [WorkerManagerTypeId]: WorkerManagerTypeId,
+    spawn<I, O, E>({ encode, initialMessage, queue, transfers = (_) => [] }: Worker.Worker.Options<I>) {
+      return Effect.gen(function* (_) {
+        const spawn = yield* _(Spawner)
+        const id = idCounter++
+        let requestIdCounter = 0
+        const requestMap = new Map<
+          number,
+          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<void>()
+          const backing = yield* platform.spawn<Worker.Worker.Request, Worker.Worker.Response<E, O>>(spawn(id))
+          const send = pipe(
+            sendQueue.take,
+            Effect.flatMap(([message, transfers]) => backing.send(message, transfers)),
+            Effect.forever,
+          )
+          const take = pipe(
+            Queue.take(backing.queue),
+            Effect.flatMap((msg) => {
+              if (msg[0] === 0) {
+                return Deferred.complete(readyLatch, Effect.void)
+              }
+              return handleMessage(msg[1])
+            }),
+            Effect.forever,
+          )
+          return yield* Effect.all(
+            [Fiber.join(backing.fiber), Effect.zipRight(Deferred.await(readyLatch), send), take],
+            { concurrency: 'unbounded' },
+          )
+        }).pipe(
+          Effect.scoped,
+          Effect.onError((cause) =>
+            Effect.forEach(requestMap.values(), ([queue]) => Queue.offer(queue, Exit.failCause(cause))),
+          ),
+          Effect.retry(Schedule.spaced(1000)),
+          Effect.annotateLogs({
+            package: '@effect/platform',
+            module: 'Worker',
+          }),
+          Effect.interruptible,
+          Effect.forkScoped,
+        )
+
+        yield* Effect.addFinalizer(() =>
+          Effect.zipRight(
+            Effect.forEach(requestMap.values(), ([queue]) => Queue.offer(queue, Exit.failCause(Cause.empty)), {
+              discard: true,
+            }),
+            Effect.sync(() => requestMap.clear()),
+          ),
+        )
+
+        const handleMessage = (response: Worker.Worker.Response<E, O>) =>
+          Effect.suspend(() => {
+            const queue = requestMap.get(response[0])
+            if (!queue) return Effect.void
+
+            switch (response[1]) {
+              // data
+              case 0: {
+                return Queue.offer(queue[0], Exit.succeed(response[2]))
+              }
+              // end
+              case 1: {
+                return response.length === 2
+                  ? Queue.offer(queue[0], Exit.failCause(Cause.empty))
+                  : Effect.zipRight(
+                      Queue.offer(queue[0], Exit.succeed(response[2])),
+                      Queue.offer(queue[0], Exit.failCause(Cause.empty)),
+                    )
+              }
+              // error / defect
+              case 2:
+              case 3: {
+                return Queue.offer(
+                  queue[0],
+                  response[1] === 2 ? Exit.fail(response[2]) : Exit.failCause(WorkerError.decodeCause(response[2])),
+                )
+              }
+            }
+          })
+
+        const executeAcquire = (request: I) =>
+          Effect.tap(
+            Effect.all([
+              Effect.sync(() => requestIdCounter++),
+              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'),
+              ),
+            ]),
+            ([id, queue, deferred, span]) =>
+              Effect.suspend(() => {
+                requestMap.set(id, [queue, deferred])
+                return outbound.offer(id, request, span)
+              }),
+          )
+
+        const executeRelease = (
+          [id, , deferred]: [
+            number,
+            Queue.Queue<Exit.Exit<ReadonlyArray<O>, E | WorkerError>>,
+            Deferred.Deferred<void>,
+            Option.Option<Tracer.Span>,
+          ],
+          exit: Exit.Exit<unknown, unknown>,
+        ) => {
+          const release = Effect.zipRight(
+            Deferred.complete(deferred, Effect.void),
+            Effect.sync(() => requestMap.delete(id)),
+          )
+          return Exit.isFailure(exit) ? Effect.zipRight(sendQueue.offer([[id, 1]]), release) : release
+        }
+
+        const execute = (request: I) =>
+          Stream.flatMap(Stream.acquireRelease(executeAcquire(request), executeRelease), ([, queue]) => {
+            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.void : Channel.failCause(cause)),
+                onSuccess: (value) => Channel.flatMap(Channel.write(Chunk.unsafeFromArray(value)), () => loop),
+              }),
+            )
+            return Stream.fromChannel(loop)
+          })
+
+        const executeEffect = (request: I) =>
+          Effect.acquireUseRelease(
+            executeAcquire(request),
+            ([, queue]) => Effect.flatMap(Queue.take(queue), Exit.map(Arr.unsafeGet(0))),
+            executeRelease,
+          )
+
+        yield* outbound.take.pipe(
+          Effect.flatMap(([id, request, span]) =>
+            Effect.fork(
+              Effect.suspend(() => {
+                const result = requestMap.get(id)
+                if (!result) return Effect.void
+                const transferables = transfers(request)
+                const spanTuple = Option.getOrUndefined(
+                  Option.map(span, (span) => [span.traceId, span.spanId, span.sampled] as const),
+                )
+                return pipe(
+                  Effect.flatMap(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])),
+                )
+              }),
+            ),
+          ),
+          Effect.forever,
+          Effect.forkScoped,
+          Effect.interruptible,
+        )
+
+        if (initialMessage) {
+          yield* Effect.sync(initialMessage).pipe(
+            Effect.flatMap(executeEffect),
+            Effect.mapError((error) => new WorkerError({ reason: 'spawn', error })),
+          )
+        }
+
+        return { id, execute, executeEffect }
+      }).pipe(Effect.parallelFinalizers)
+    },
+  })
+})
+
+/** @internal */
+export const layerManager = Layer.effect(WorkerManager, makeManager)
+
+/** @internal */
+export const makePool = <I, O, E>(options: Worker.WorkerPool.Options<I>) =>
+  Effect.gen(function* () {
+    const manager = yield* WorkerManager
+    const workers = new Set<Worker.Worker<I, O, E>>()
+    const acquire = pipe(
+      manager.spawn<I, O, E>(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,
+    )
+    const backing =
+      'minSize' in options
+        ? yield* Pool.makeWithTTL({
+            acquire,
+            min: options.minSize,
+            max: options.maxSize,
+            concurrency: options.concurrency,
+            targetUtilization: options.targetUtilization,
+            timeToLive: options.timeToLive,
+          })
+        : yield* Pool.make({
+            acquire,
+            size: options.size,
+            concurrency: options.concurrency,
+            targetUtilization: options.targetUtilization,
+          })
+    const pool: Worker.WorkerPool<I, O, E> = {
+      backing,
+      broadcast: (message: I) =>
+        Effect.forEach(workers, (worker) => worker.executeEffect(message), {
+          concurrency: 'unbounded',
+          discard: true,
+        }),
+      execute: (message: I) => Stream.unwrapScoped(Effect.map(backing.get, (worker) => worker.execute(message))),
+      executeEffect: (message: I) =>
+        Effect.scoped(Effect.flatMap(backing.get, (worker) => worker.executeEffect(message))),
+    }
+
+    // report any spawn errors
+    yield* Effect.scoped(backing.get)
+
+    return pool
+  })
+
+/** @internal */
+export const makePoolLayer = <Tag, I, O, E>(
+  tag: Context.Tag<Tag, Worker.WorkerPool<I, O, E>>,
+  options: Worker.WorkerPool.Options<I>,
+) => Layer.scoped(tag, makePool(options))
+
+/** @internal */
+export const makeSerialized = <I extends Schema.TaggedRequest.Any>(
+  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),
+      encode(message) {
+        return Effect.mapError(
+          Serializable.serialize(message as any),
+          (error) => new WorkerError({ reason: 'encode', error }),
+        )
+      },
+    })
+    const execute = <Req extends I>(message: Req) => {
+      const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
+      const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
+      return pipe(
+        backing.execute(message),
+        Stream.catchAll((error) => Effect.flatMap(parseFailure(error), Effect.fail)),
+        Stream.mapEffect(parseSuccess),
+      )
+    }
+    const executeEffect = <Req extends I>(message: Req) => {
+      const parseSuccess = Schema.decode(Serializable.successSchema(message as any))
+      const parseFailure = Schema.decode(Serializable.failureSchema(message as any))
+      return Effect.matchEffect(backing.executeEffect(message), {
+        onFailure: (error) => Effect.flatMap(parseFailure(error), Effect.fail),
+        onSuccess: parseSuccess,
+      })
+    }
+    return identity<Worker.SerializedWorker<I>>({
+      id: backing.id,
+      execute: execute as any,
+      executeEffect: executeEffect as any,
+    })
+  })
+
+/** @internal */
+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>(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 as (worker: Worker.SerializedWorker<I>) => Effect.Effect<void, WorkerError>)
+        : identity,
+      Effect.provideService(WorkerManager, manager),
+    )
+    const backing = yield* 'timeToLive' in options
+      ? Pool.makeWithTTL({
+          acquire,
+          min: options.minSize,
+          max: options.maxSize,
+          concurrency: options.concurrency,
+          targetUtilization: options.targetUtilization,
+          timeToLive: options.timeToLive,
+        })
+      : Pool.make({
+          acquire,
+          size: options.size,
+          concurrency: options.concurrency,
+          targetUtilization: options.targetUtilization,
+        })
+    const pool: Worker.SerializedWorkerPool<I> = {
+      backing,
+      broadcast: <Req extends I>(message: Req) =>
+        Effect.forEach(workers, (worker) => worker.executeEffect(message), {
+          concurrency: 'unbounded',
+          discard: true,
+        }) as any,
+      execute: <Req extends I>(message: Req) =>
+        Stream.unwrapScoped(Effect.map(backing.get, (worker) => worker.execute(message))) as any,
+      executeEffect: <Req extends I>(message: Req) =>
+        Effect.scoped(Effect.flatMap(backing.get, (worker) => worker.executeEffect(message))) as any,
+    }
+
+    // report any spawn errors
+    yield* Effect.scoped(backing.get)
+
+    return pool
+  })
+
+/** @internal */
+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/effect/worker-tmp/internal/workerError.ts

@@ -0,0 +1,6 @@
+import type * as WorkerError_ from "../WorkerError.js"
+
+/** @internal */
+export const WorkerErrorTypeId: WorkerError_.WorkerErrorTypeId = Symbol.for(
+  "@effect/platform/WorkerError"
+) as WorkerError_.WorkerErrorTypeId

package/src/effect/worker-tmp/internal/workerRunner.ts

@@ -0,0 +1,236 @@
+import { Transferable } from '@effect/platform'
+import * as Schema from '@effect/schema/Schema'
+import * as Serializable from '@effect/schema/Serializable'
+import * 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 Either from 'effect/Either'
+import * as ExecutionStrategy from 'effect/ExecutionStrategy'
+import * as Exit from 'effect/Exit'
+import * as Fiber from 'effect/Fiber'
+import { identity, pipe } from 'effect/Function'
+import * as Layer from 'effect/Layer'
+import * as Option from 'effect/Option'
+import * as Queue from 'effect/Queue'
+import * as Scope from 'effect/Scope'
+import * as Stream from 'effect/Stream'
+
+import type * as Worker from '../Worker.js'
+import { isWorkerError, WorkerError } from '../WorkerError.js'
+import type * as WorkerRunner from '../WorkerRunner.js'
+
+/** @internal */
+export const PlatformRunnerTypeId: WorkerRunner.PlatformRunnerTypeId = Symbol.for(
+  '@effect/platform/Runner/PlatformRunner',
+) as WorkerRunner.PlatformRunnerTypeId
+
+/** @internal */
+export const PlatformRunner = Context.GenericTag<WorkerRunner.PlatformRunner>('@effect/platform/Runner/PlatformRunner')
+
+/** @internal */
+export const make = <I, E, R, O>(
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
+  options?: WorkerRunner.Runner.Options<I, O, E>,
+) =>
+  Effect.gen(function* (_) {
+    const scope = yield* _(Scope.fork(yield* _(Effect.scope), ExecutionStrategy.parallel))
+    const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
+    const shutdown = Effect.zipRight(Scope.close(scope, Exit.void), Fiber.interruptFork(fiber))
+    const platform = yield* _(PlatformRunner)
+    const backing = yield* _(
+      platform.start<Worker.Worker.Request<I>, Worker.Worker.Response<E>>(shutdown),
+      Scope.extend(scope),
+    )
+    const fiberMap = new Map<number, Fiber.Fiber<void, unknown>>()
+
+    yield* _(
+      Queue.take(backing.queue),
+      options?.decode
+        ? Effect.flatMap((msg): Effect.Effect<readonly [portId: number, Worker.Worker.Request<I>], WorkerError> => {
+            const req = msg[1]
+            if (req[1] === 1) {
+              return Effect.succeed(msg)
+            }
+
+            return Effect.map(options.decode!(req[2]), (data) => [msg[0], [req[0], req[1], data, req[3]]])
+          })
+        : identity,
+      Effect.tap(([portId, req]) => {
+        const id = req[0]
+        if (req[1] === 1) {
+          const fiber = fiberMap.get(id)
+          if (!fiber) return Effect.void
+          return Fiber.interrupt(fiber)
+        }
+
+        const collector = Transferable.unsafeMakeCollector()
+        return pipe(
+          Effect.sync(() => process(req[2])),
+          Effect.flatMap((stream) => {
+            let effect = Effect.isEffect(stream)
+              ? Effect.flatMap(stream, (data) => {
+                  const transfers = options?.transfers ? options.transfers(data) : []
+                  return pipe(
+                    options?.encodeOutput
+                      ? Effect.provideService(options.encodeOutput(req[2], data), Transferable.Collector, collector)
+                      : Effect.succeed(data),
+                    Effect.flatMap((payload) =>
+                      backing.send(portId, [id, 0, [payload]], [...transfers, ...collector.unsafeRead()]),
+                    ),
+                  )
+                })
+              : pipe(
+                  stream,
+                  Stream.chunks,
+                  Stream.tap((data) => {
+                    if (options?.encodeOutput === undefined) {
+                      const payload = Chunk.toReadonlyArray(data)
+                      const transfers = options?.transfers ? payload.flatMap(options.transfers) : undefined
+                      return backing.send(portId, [id, 0, payload], transfers)
+                    }
+
+                    const transfers: unknown[] = []
+                    collector.unsafeClear()
+                    return pipe(
+                      Effect.forEach(data, (data) => {
+                        if (options?.transfers) {
+                          for (const option of options.transfers(data)) {
+                            transfers.push(option)
+                          }
+                        }
+                        return Effect.orDie(options.encodeOutput!(req[2], data))
+                      }),
+                      Effect.provideService(Transferable.Collector, collector),
+                      Effect.flatMap((payload) => {
+                        collector.unsafeRead().forEach((transfer) => transfers.push(transfer))
+                        return backing.send(portId, [id, 0, payload], transfers)
+                      }),
+                    )
+                  }),
+                  Stream.runDrain,
+                  Effect.andThen(backing.send(portId, [id, 1])),
+                )
+
+            if (req[3]) {
+              const [traceId, spanId, sampled] = req[3]
+              effect = Effect.withParentSpan(effect, {
+                _tag: 'ExternalSpan',
+                traceId,
+                spanId,
+                sampled,
+                context: Context.empty(),
+              })
+            }
+
+            return effect
+          }),
+          Effect.catchIf(isWorkerError, (error) =>
+            backing.send(portId, [id, 3, WorkerError.encodeCause(Cause.fail(error))]),
+          ),
+          Effect.onExit((exit) => {
+            if (exit._tag === 'Success') {
+              return Effect.void
+            }
+            return Either.match(Cause.failureOrCause(exit.cause), {
+              onLeft: (error) => {
+                const transfers = options?.transfers ? options.transfers(error) : []
+                collector.unsafeClear()
+                return pipe(
+                  options?.encodeError
+                    ? Effect.provideService(options.encodeError(req[2], error), Transferable.Collector, collector)
+                    : Effect.succeed(error),
+                  Effect.flatMap((payload) =>
+                    backing.send(portId, [id, 2, payload as any], [...transfers, ...collector.unsafeRead()]),
+                  ),
+                  Effect.catchAllCause((cause) => backing.send(portId, [id, 3, WorkerError.encodeCause(cause)])),
+                )
+              },
+              onRight: (cause) => backing.send(portId, [id, 3, WorkerError.encodeCause(cause)]),
+            })
+          }),
+          Effect.ensuring(Effect.sync(() => fiberMap.delete(id))),
+          Effect.fork,
+          Effect.tap((fiber) => Effect.sync(() => fiberMap.set(id, fiber))),
+        )
+      }),
+      Effect.forever,
+      Effect.forkIn(scope),
+    )
+  })
+
+/** @internal */
+export const layer = <I, E, R, O>(
+  process: (request: I) => Stream.Stream<O, E, R> | Effect.Effect<O, E, R>,
+  options?: WorkerRunner.Runner.Options<I, O, E>,
+): Layer.Layer<never, WorkerError, WorkerRunner.PlatformRunner | R> => Layer.scopedDiscard(make(process, options))
+
+/** @internal */
+export const makeSerialized = <
+  R,
+  I,
+  A extends Schema.TaggedRequest.Any,
+  const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>,
+>(
+  schema: Schema.Schema<A, I, R>,
+  handlers: Handlers,
+): Effect.Effect<
+  void,
+  WorkerError,
+  R | WorkerRunner.PlatformRunner | Scope.Scope | 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<A>
+
+    return yield* _(
+      make(
+        (request: A) => {
+          const result = (handlers as any)[request._tag](request)
+          if (Layer.isLayer(result)) {
+            return Effect.flatMap(Layer.buildWithScope(result, scope), (_) =>
+              Effect.sync(() => {
+                context = Context.merge(context, _)
+              }),
+            )
+          } else if (Effect.isEffect(result)) {
+            return Effect.provide(result, context)
+          }
+          return Stream.provideContext(result as any, context)
+        },
+        {
+          decode(message) {
+            return Effect.mapError(parseRequest(message), (error) => new WorkerError({ reason: 'decode', error }))
+          },
+          encodeError(request, message) {
+            return Effect.mapError(
+              Serializable.serializeFailure(request as any, message),
+              (error) => new WorkerError({ reason: 'encode', error }),
+            )
+          },
+          encodeOutput(request, message) {
+            return Effect.catchAllCause(
+              Serializable.serializeSuccess(request as any, message),
+              (error) => new WorkerError({ reason: 'encode', error }),
+            )
+          },
+        },
+      ),
+    )
+  }) as any
+
+/** @internal */
+export const layerSerialized = <
+  R,
+  I,
+  A extends Schema.TaggedRequest.Any,
+  const Handlers extends WorkerRunner.SerializedRunner.Handlers<A>,
+>(
+  schema: Schema.Schema<A, I, R>,
+  handlers: Handlers,
+): Layer.Layer<
+  never,
+  WorkerError,
+  R | WorkerRunner.PlatformRunner | WorkerRunner.SerializedRunner.HandlersContext<Handlers>
+> => Layer.scopedDiscard(makeSerialized(schema, handlers))