Function spawn

packages/platform/src/internal/worker.ts:54–220

({
      encode,
      initialMessage
    }: Worker.Worker.Options<I>)

  return WorkerManager.of({
    [WorkerManagerTypeId]: WorkerManagerTypeId,
    spawn<I, O, E>({
      encode,
      initialMessage
    }: Worker.Worker.Options<I>) {
      return Effect.gen(function*() {
        const id = idCounter++
        let requestIdCounter = 0
        const requestMap = new Map<
          number,
          Mailbox.Mailbox<O, E | WorkerError> | Deferred.Deferred<O, E | WorkerError>
        >()

        const collector = Transferable.unsafeMakeCollector()
        const wrappedEncode = encode ?
          ((message: I) =>
            Effect.zipRight(
              collector.clear,
              Effect.provideService(encode(message), Transferable.Collector, collector)
            )) :
          Effect.succeed

        const readyLatch = yield* Deferred.make<void>()
        const backing = yield* platform.spawn<Worker.Worker.Request, Worker.Worker.Response<E, O>>(id)

        yield* backing.run((message) => {
          if (message[0] === 0) {
            return Deferred.complete(readyLatch, Effect.void)
          }
          return handleMessage(message[1])
        }).pipe(
          Effect.onError((cause) =>
            Effect.forEach(requestMap.values(), (mailbox) =>
              Deferred.DeferredTypeId in mailbox
                ? Deferred.failCause(mailbox, cause)
                : mailbox.failCause(cause))
          ),
          Effect.tapErrorCause(Effect.logWarning),
          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(), (mailbox) =>
              Deferred.DeferredTypeId in mailbox
                ? Deferred.interrupt(mailbox)
                : mailbox.end, {
              discard: true
            }),
            Effect.sync(() => requestMap.clear())
          )
        )