@effect/platform 0.75.4 → 0.76.1

package/src/internal/workerRunner.ts

@@ -1,12 +1,13 @@
 import * as Cause from "effect/Cause"
 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 Either from "effect/Either"
 import * as Fiber from "effect/Fiber"
+import * as FiberId from "effect/FiberId"
 import { pipe } from "effect/Function"
 import * as Layer from "effect/Layer"
-import * as Schedule from "effect/Schedule"
 import * as Schema from "effect/Schema"
 import type * as Scope from "effect/Scope"
 import * as Stream from "effect/Stream"
@@ -26,125 +27,114 @@ export const PlatformRunner = Context.GenericTag<WorkerRunner.PlatformRunner>(
 )
 
 /** @internal */
-export const run = <I, E, R, O>(
+export const CloseLatch = Context.Reference<WorkerRunner.CloseLatch>()("@effect/platform/WorkerRunner/CloseLatch", {
+  defaultValue: () => Deferred.unsafeMake<void, WorkerError>(FiberId.none)
+})
+
+/** @internal */
+export const layerCloseLatch = Layer.effect(CloseLatch, Deferred.make())
+
+/** @internal */
+export const make = Effect.fnUntraced(function*<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 platform = yield* PlatformRunner
-    const backing = yield* platform.start<Worker.Worker.Request<I>, Worker.Worker.Response<E>>()
-    const fiberMap = new Map<number, Fiber.Fiber<unknown, unknown>>()
+) {
+  const platform = yield* PlatformRunner
+  const closeLatch = yield* CloseLatch
+  const backing = yield* platform.start<Worker.Worker.Request<I>, Worker.Worker.Response<E>>(closeLatch)
+  const fiberMap = new Map<number, Fiber.Fiber<unknown, unknown>>()
 
-    return yield* backing.run((portId, [id, kind, data, span]): Effect.Effect<void, WorkerError, R> => {
-      if (kind === 1) {
-        const fiber = fiberMap.get(id)
-        if (!fiber) return Effect.void
-        return Fiber.interrupt(fiber)
-      }
+  yield* backing.run((portId, [id, kind, data, span]): Effect.Effect<void, WorkerError, R> => {
+    if (kind === 1) {
+      const fiber = fiberMap.get(id)
+      if (!fiber) return Effect.void
+      return Fiber.interrupt(fiber)
+    }
 
-      return Effect.withFiberRuntime<I, WorkerError>((fiber) => {
-        fiberMap.set(id, fiber)
-        return options?.decode ? options.decode(data) : Effect.succeed(data)
-      }).pipe(
-        Effect.flatMap((input) => {
-          const collector = Transferable.unsafeMakeCollector()
-          const stream = process(input)
-          let effect = Effect.isEffect(stream) ?
-            Effect.flatMap(stream, (out) =>
-              pipe(
-                options?.encodeOutput
-                  ? Effect.provideService(options.encodeOutput(input, out), Transferable.Collector, collector)
-                  : Effect.succeed(out),
-                Effect.flatMap((payload) => backing.send(portId, [id, 0, [payload]], collector.unsafeRead()))
-              )) :
+    return Effect.withFiberRuntime<I, WorkerError>((fiber) => {
+      fiberMap.set(id, fiber)
+      return options?.decode ? options.decode(data) : Effect.succeed(data)
+    }).pipe(
+      Effect.flatMap((input) => {
+        const collector = Transferable.unsafeMakeCollector()
+        const stream = process(input)
+        let effect = Effect.isEffect(stream) ?
+          Effect.flatMap(stream, (out) =>
             pipe(
-              stream,
-              Stream.runForEachChunk((chunk) => {
-                if (options?.encodeOutput === undefined) {
-                  const payload = Chunk.toReadonlyArray(chunk)
-                  return backing.send(portId, [id, 0, payload])
-                }
+              options?.encodeOutput
+                ? Effect.provideService(options.encodeOutput(input, out), Transferable.Collector, collector)
+                : Effect.succeed(out),
+              Effect.flatMap((payload) => backing.send(portId, [id, 0, [payload]], collector.unsafeRead()))
+            )) :
+          pipe(
+            stream,
+            Stream.runForEachChunk((chunk) => {
+              if (options?.encodeOutput === undefined) {
+                const payload = Chunk.toReadonlyArray(chunk)
+                return backing.send(portId, [id, 0, payload])
+              }
 
-                collector.unsafeClear()
-                return pipe(
-                  Effect.forEach(chunk, (data) => options.encodeOutput!(input, data)),
-                  Effect.provideService(Transferable.Collector, collector),
-                  Effect.flatMap((payload) => backing.send(portId, [id, 0, payload], collector.unsafeRead()))
-                )
-              }),
-              Effect.andThen(backing.send(portId, [id, 1]))
-            )
+              collector.unsafeClear()
+              return pipe(
+                Effect.forEach(chunk, (data) => options.encodeOutput!(input, data)),
+                Effect.provideService(Transferable.Collector, collector),
+                Effect.flatMap((payload) => backing.send(portId, [id, 0, payload], collector.unsafeRead()))
+              )
+            }),
+            Effect.andThen(backing.send(portId, [id, 1]))
+          )
 
-          if (span) {
-            effect = Effect.withParentSpan(effect, {
-              _tag: "ExternalSpan",
-              traceId: span[0],
-              spanId: span[1],
-              sampled: span[2],
-              context: Context.empty()
-            })
-          }
+        if (span) {
+          effect = Effect.withParentSpan(effect, {
+            _tag: "ExternalSpan",
+            traceId: span[0],
+            spanId: span[1],
+            sampled: span[2],
+            context: Context.empty()
+          })
+        }
 
-          return Effect.uninterruptibleMask((restore) =>
-            restore(effect).pipe(
-              Effect.catchIf(
-                isWorkerError,
-                (error) => backing.send(portId, [id, 3, WorkerError.encodeCause(Cause.fail(error))])
-              ),
-              Effect.catchAllCause((cause) =>
-                Either.match(Cause.failureOrCause(cause), {
-                  onLeft: (error) => {
-                    collector.unsafeClear()
-                    return pipe(
-                      options?.encodeError
-                        ? Effect.provideService(
-                          options.encodeError(input, error),
-                          Transferable.Collector,
-                          collector
-                        )
-                        : Effect.succeed(error),
-                      Effect.flatMap((payload) =>
-                        backing.send(portId, [id, 2, payload as any], collector.unsafeRead())
-                      ),
-                      Effect.catchAllCause((cause) => backing.send(portId, [id, 3, WorkerError.encodeCause(cause)]))
-                    )
-                  },
-                  onRight: (cause) => backing.send(portId, [id, 3, WorkerError.encodeCause(cause)])
-                })
-              )
+        return Effect.uninterruptibleMask((restore) =>
+          restore(effect).pipe(
+            Effect.catchIf(
+              isWorkerError,
+              (error) => backing.send(portId, [id, 3, WorkerError.encodeCause(Cause.fail(error))])
+            ),
+            Effect.catchAllCause((cause) =>
+              Either.match(Cause.failureOrCause(cause), {
+                onLeft: (error) => {
+                  collector.unsafeClear()
+                  return pipe(
+                    options?.encodeError
+                      ? Effect.provideService(
+                        options.encodeError(input, error),
+                        Transferable.Collector,
+                        collector
+                      )
+                      : Effect.succeed(error),
+                    Effect.flatMap((payload) => backing.send(portId, [id, 2, payload as any], 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)))
-      )
-    })
-  })
-
-/** @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.Effect<void, WorkerError, WorkerRunner.PlatformRunner | R | Scope.Scope> =>
-  Effect.withFiberRuntime<void, never, WorkerRunner.PlatformRunner | R | Scope.Scope>((fiber) =>
-    run(process, options).pipe(
-      Effect.tapErrorCause((cause) => Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logWarning(cause)),
-      Effect.retry(Schedule.spaced(1000)),
-      Effect.annotateLogs({
-        package: "@effect/platform-node",
-        module: "WorkerRunner"
+        )
       }),
-      Effect.ensuring(Fiber.interruptAsFork(fiber, fiber.id())),
-      Effect.interruptible,
-      Effect.forkScoped,
-      Effect.asVoid
+      Effect.ensuring(Effect.sync(() => fiberMap.delete(id)))
     )
-  )
+  })
+})
 
 /** @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))
+): Layer.Layer<never, WorkerError, WorkerRunner.PlatformRunner | R> =>
+  Layer.scopedDiscard(make(process, options)).pipe(
+    Layer.provide(layerCloseLatch)
+  )
 
 /** @internal */
 export const makeSerialized = <
@@ -216,4 +206,14 @@ export const layerSerialized = <
   | R
   | WorkerRunner.PlatformRunner
   | WorkerRunner.SerializedRunner.HandlersContext<Handlers>
-> => Layer.scopedDiscard(makeSerialized(schema, handlers))
+> => Layer.scopedDiscard(makeSerialized(schema, handlers)).pipe(Layer.provide(layerCloseLatch))
+
+/** @internal */
+export const launch = <A, E, R>(layer: Layer.Layer<A, E, R>): Effect.Effect<void, E | WorkerError, R> =>
+  Effect.scopedWith(Effect.fnUntraced(function*(scope) {
+    const context = yield* Layer.buildWithScope(Layer.merge(layer, layerCloseLatch), scope)
+    const closeLatch = Context.get(context, CloseLatch)
+    return yield* Effect.never.pipe(
+      Effect.raceFirst(Deferred.await(closeLatch))
+    )
+  }))