@effect/platform 0.69.17 → 0.69.19

package/src/Socket.ts

@@ -397,7 +397,7 @@ export const fromWebSocket = <RO>(
 ): Effect.Effect<Socket, never, Exclude<RO, Scope.Scope>> =>
   Effect.gen(function*() {
     const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
-    const sendQueue = yield* Mailbox.make<Uint8Array | string, SocketError>({
+    const sendQueue = yield* Mailbox.make<Uint8Array | string | CloseEvent>({
       capacity: fiber.getFiberRef(currentSendQueueCapacity),
       strategy: "dropping"
     })
@@ -465,22 +465,25 @@ export const fromWebSocket = <RO>(
           )
         }
         open = true
-        yield* sendQueue.takeAll.pipe(
-          Effect.tap(([chunk]) =>
-            Effect.try({
-              try: () => {
-                for (const item of chunk) {
-                  ws.send(item)
-                }
-              },
+        yield* sendQueue.take.pipe(
+          Effect.tap((chunk) => {
+            if (isCloseEvent(chunk)) {
+              ws.close(chunk.code, chunk.reason)
+              return Effect.fail(
+                new SocketCloseError({
+                  reason: "Close",
+                  code: chunk.code,
+                  closeReason: chunk.reason
+                })
+              )
+            }
+            return Effect.try({
+              try: () => ws.send(chunk),
               catch: (cause) => new SocketGenericError({ reason: "Write", cause })
             })
-          ),
-          Effect.forever,
-          Effect.catchIf(SocketCloseError.is, (error) => {
-            ws.close(error.code, error.closeReason)
-            return Effect.fail(error)
           }),
+          Effect.forever,
+          Effect.catchTag("NoSuchElementException", () => Effect.void),
           FiberSet.run(fiberSet)
         )
         return yield* FiberSet.join(fiberSet).pipe(
@@ -503,16 +506,7 @@ export const fromWebSocket = <RO>(
           : handler(data)
       )
 
-    const write = (chunk: Uint8Array | string | CloseEvent) =>
-      isCloseEvent(chunk)
-        ? sendQueue.fail(
-          new SocketCloseError({
-            reason: "Close",
-            code: chunk.code,
-            closeReason: chunk.reason
-          })
-        )
-        : sendQueue.offer(chunk)
+    const write = (chunk: Uint8Array | string | CloseEvent) => sendQueue.offer(chunk)
     const writer = Effect.succeed(write)
 
     return Socket.of({
@@ -584,7 +578,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
 }): Effect.Effect<Socket, never, Exclude<R, Scope.Scope>> =>
   Effect.gen(function*() {
     const fiber = Option.getOrThrow(Fiber.getCurrentFiber())
-    const sendQueue = yield* Mailbox.make<Uint8Array | string, SocketError>({
+    const sendQueue = yield* Mailbox.make<Uint8Array | string | CloseEvent>({
       capacity: fiber.getFiberRef(currentSendQueueCapacity),
       strategy: "dropping"
     })
@@ -608,23 +602,24 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
         )
         const fiberSet = yield* FiberSet.make<any, E | SocketError>()
         const encoder = new TextEncoder()
-        yield* sendQueue.takeAll.pipe(
-          Effect.flatMap(([chunk, done]) => {
-            const write = Effect.try({
-              try: () => {
-                for (const item of chunk) {
-                  if (typeof item === "string") {
-                    writer.write(encoder.encode(item))
-                  } else {
-                    writer.write(item)
-                  }
-                }
-              },
+        yield* sendQueue.take.pipe(
+          Effect.tap((chunk) => {
+            if (isCloseEvent(chunk)) {
+              return Effect.fail(
+                new SocketCloseError({
+                  reason: "Close",
+                  code: chunk.code,
+                  closeReason: chunk.reason
+                })
+              )
+            }
+            return Effect.tryPromise({
+              try: () => writer.write(typeof chunk === "string" ? encoder.encode(chunk) : chunk),
               catch: (cause) => new SocketGenericError({ reason: "Write", cause })
             })
-            return done ? Effect.zipRight(write, Effect.interrupt) : write
           }),
           Effect.forever,
+          Effect.catchTag("NoSuchElementException", () => Effect.void),
           Effect.ensuring(Effect.promise(() => writer.close())),
           FiberSet.run(fiberSet)
         )
@@ -663,16 +658,7 @@ export const fromTransformStream = <R>(acquire: Effect.Effect<InputTransformStre
           : handler(data)
       )
 
-    const write = (chunk: Uint8Array | string | CloseEvent) =>
-      isCloseEvent(chunk) ?
-        sendQueue.fail(
-          new SocketCloseError({
-            reason: "Close",
-            code: chunk.code,
-            closeReason: chunk.reason
-          })
-        ) :
-        sendQueue.offer(chunk)
+    const write = (chunk: Uint8Array | string | CloseEvent) => sendQueue.offer(chunk)
     const writer = Effect.acquireRelease(
       Effect.succeed(write),
       () => sendQueue.end

package/src/Worker.ts

@@ -66,7 +66,7 @@ export const makePlatform: <W>() => <
   P extends { readonly postMessage: (message: any, transfers?: any | undefined) => void }
 >(
   options: {
-    readonly setup: (options: { readonly worker: W; readonly scope: Scope.Scope }) => Effect.Effect<P>
+    readonly setup: (options: { readonly worker: W; readonly scope: Scope.Scope }) => Effect.Effect<P, WorkerError>
     readonly listen: (
       options: {
         readonly port: P

package/src/internal/worker.ts

@@ -1,3 +1,4 @@
+import { Runtime } from "effect"
 import * as Channel from "effect/Channel"
 import * as Context from "effect/Context"
 import * as Deferred from "effect/Deferred"
@@ -86,6 +87,7 @@ export const makeManager = Effect.gen(function*() {
                 ? Deferred.failCause(mailbox, cause)
                 : mailbox.failCause(cause))
           ),
+          Effect.tapErrorCause(Effect.logWarning),
           Effect.retry(Schedule.spaced(1000)),
           Effect.annotateLogs({
             package: "@effect/platform",
@@ -401,7 +403,7 @@ export const makePlatform = <W>() =>
   readonly setup: (options: {
     readonly worker: W
     readonly scope: Scope.Scope
-  }) => Effect.Effect<P>
+  }) => Effect.Effect<P, WorkerError>
   readonly listen: (options: {
     readonly port: P
     readonly emit: (data: any) => void
@@ -417,49 +419,41 @@ export const makePlatform = <W>() =>
         let currentPort: P | undefined
         const buffer: Array<[I, ReadonlyArray<unknown> | undefined]> = []
 
-        const run = <A, E, R>(handler: (_: Worker.BackingWorker.Message<O>) => Effect.Effect<A, E, R>) =>
+        const run = <A, E, R>(
+          handler: (_: Worker.BackingWorker.Message<O>) => Effect.Effect<A, E, R>
+        ): Effect.Effect<never, WorkerError | E, R> =>
           Effect.uninterruptibleMask((restore) =>
-            Scope.make().pipe(
-              Effect.bindTo("scope"),
-              Effect.bind("port", ({ scope }) => options.setup({ worker: spawn(id), scope })),
-              Effect.tap(({ port, scope }) => {
-                currentPort = port
-                return Scope.addFinalizer(
-                  scope,
-                  Effect.sync(() => {
-                    currentPort = undefined
-                  })
-                )
-              }),
-              Effect.bind("fiberSet", ({ scope }) =>
-                FiberSet.make<any, WorkerError | E>().pipe(
-                  Scope.extend(scope)
-                )),
-              Effect.bind("runFork", ({ fiberSet }) => FiberSet.runtime(fiberSet)<R>()),
-              Effect.tap(({ fiberSet, port, runFork, scope }) =>
-                options.listen({
-                  port,
-                  scope,
-                  emit(data) {
-                    runFork(handler(data))
-                  },
-                  deferred: fiberSet.deferred as any
+            Effect.gen(function*() {
+              const scope = yield* Effect.scope
+              const port = yield* options.setup({ worker: spawn(id), scope })
+              currentPort = port
+              yield* Scope.addFinalizer(
+                scope,
+                Effect.sync(() => {
+                  currentPort = undefined
                 })
-              ),
-              Effect.tap(({ port }) => {
-                if (buffer.length > 0) {
-                  for (const [message, transfers] of buffer) {
-                    port.postMessage([0, message], transfers as any)
-                  }
-                  buffer.length = 0
-                }
-              }),
-              Effect.flatMap(({ fiberSet, scope }) =>
-                (restore(FiberSet.join(fiberSet)) as Effect.Effect<never, WorkerError | E>).pipe(
-                  Effect.ensuring(Scope.close(scope, Exit.void))
-                )
               )
-            )
+              const runtime = (yield* Effect.runtime<R | Scope.Scope>()).pipe(
+                Runtime.updateContext(Context.omit(Scope.Scope))
+              ) as Runtime.Runtime<R>
+              const fiberSet = yield* FiberSet.make<any, WorkerError | E>()
+              const runFork = Runtime.runFork(runtime)
+              yield* options.listen({
+                port,
+                scope,
+                emit(data) {
+                  FiberSet.unsafeAdd(runFork(handler(data)))
+                },
+                deferred: fiberSet.deferred as any
+              })
+              if (buffer.length > 0) {
+                for (const [message, transfers] of buffer) {
+                  port.postMessage([0, message], transfers as any)
+                }
+                buffer.length = 0
+              }
+              return (yield* restore(FiberSet.join(fiberSet))) as never
+            }).pipe(Effect.scoped)
           )
 
         const send = (message: I, transfers?: ReadonlyArray<unknown>) =>

package/src/internal/workerRunner.ts

@@ -127,7 +127,7 @@ export const make = <I, E, R, O>(
 ): 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(Effect.logDebug),
+      Effect.tapErrorCause((cause) => Cause.isInterruptedOnly(cause) ? Effect.void : Effect.logWarning(cause)),
       Effect.retry(Schedule.spaced(1000)),
       Effect.annotateLogs({
         package: "@effect/platform-node",