@livestore/utils 0.3.0-dev.9 → 0.3.0

package/src/effect/WebChannel/common.ts

@@ -1,5 +1,5 @@
-import type { Deferred, Effect, Either, ParseResult, Schema, Stream } from 'effect'
-import { Predicate } from 'effect'
+import type { Deferred, Either, ParseResult } from 'effect'
+import { Effect, Predicate, Schema, Stream } from 'effect'
 
 export const WebChannelSymbol = Symbol('WebChannel')
 export type WebChannelSymbol = typeof WebChannelSymbol
@@ -13,5 +13,64 @@ export interface WebChannel<MsgListen, MsgSend, E = never> {
   listen: Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, E>
   supportsTransferables: boolean
   closedDeferred: Deferred.Deferred<void>
+  shutdown: Effect.Effect<void>
   schema: { listen: Schema.Schema<MsgListen, any>; send: Schema.Schema<MsgSend, any> }
+  debugInfo?: Record<string, any>
 }
+
+export const DebugPingMessage = Schema.TaggedStruct('WebChannel.DebugPing', {
+  message: Schema.String,
+  payload: Schema.optional(Schema.String),
+})
+
+export const WebChannelPing = Schema.TaggedStruct('WebChannel.Ping', {
+  requestId: Schema.String,
+})
+
+export const WebChannelPong = Schema.TaggedStruct('WebChannel.Pong', {
+  requestId: Schema.String,
+})
+
+export const WebChannelHeartbeat = Schema.Union(WebChannelPing, WebChannelPong)
+
+type WebChannelMessages = typeof DebugPingMessage.Type | typeof WebChannelPing.Type | typeof WebChannelPong.Type
+
+export const schemaWithWebChannelMessages = <MsgListen, MsgSend>(
+  schema: OutputSchema<MsgListen, MsgSend, any, any>,
+): OutputSchema<MsgListen | WebChannelMessages, MsgSend | WebChannelMessages, any, any> => ({
+  send: Schema.Union(schema.send, DebugPingMessage, WebChannelPing, WebChannelPong),
+  listen: Schema.Union(schema.listen, DebugPingMessage, WebChannelPing, WebChannelPong),
+})
+
+export type InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> =
+  | Schema.Schema<MsgListen | MsgSend, MsgListenEncoded | MsgSendEncoded>
+  | OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>
+
+export type OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> = {
+  listen: Schema.Schema<MsgListen, MsgListenEncoded>
+  send: Schema.Schema<MsgSend, MsgSendEncoded>
+}
+
+export const mapSchema = <MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>(
+  schema: InputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded>,
+): OutputSchema<MsgListen, MsgSend, MsgListenEncoded, MsgSendEncoded> =>
+  Predicate.hasProperty(schema, 'send') && Predicate.hasProperty(schema, 'listen')
+    ? (schemaWithWebChannelMessages(schema) as any)
+    : (schemaWithWebChannelMessages({ send: schema, listen: schema }) as any)
+
+export const listenToDebugPing =
+  (channelName: string) =>
+  <MsgListen>(
+    stream: Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, never>,
+  ): Stream.Stream<Either.Either<MsgListen, ParseResult.ParseError>, never> =>
+    stream.pipe(
+      Stream.filterEffect(
+        Effect.fn(function* (msg) {
+          if (msg._tag === 'Right' && Schema.is(DebugPingMessage)(msg.right)) {
+            yield* Effect.logDebug(`WebChannel:ping [${channelName}] ${msg.right.message}`, msg.right.payload)
+            return false
+          }
+          return true
+        }),
+      ),
+    )

package/src/effect/WebChannel/mod.ts

@@ -0,0 +1,3 @@
+export * from './WebChannel.js'
+export * from './broadcastChannelWithAck.js'
+export * from './common.js'

package/src/effect/WebSocket.test.ts

@@ -0,0 +1,15 @@
+import { FetchHttpClient } from '@effect/platform'
+import * as Vitest from '@effect/vitest'
+import { Effect, Exit } from 'effect'
+
+import { makeWebSocket } from './WebSocket.js'
+
+Vitest.describe('WebSocket', () => {
+  Vitest.scopedLive(
+    'should create a WebSocket connection',
+    Effect.fn(function* () {
+      const exit = yield* makeWebSocket({ url: 'ws://localhost:1000' }).pipe(Effect.timeout(500), Effect.exit)
+      Vitest.expect(Exit.isFailure(exit)).toBe(true)
+    }, Effect.provide(FetchHttpClient.layer)),
+  )
+})

package/src/effect/WebSocket.ts

@@ -1,3 +1,4 @@
+import { HttpClient } from '@effect/platform'
 import type { Schedule, Scope } from 'effect'
 import { Effect, Exit, identity, Schema } from 'effect'
 
@@ -20,53 +21,91 @@ export const makeWebSocket = ({
 }: {
   url: string
   reconnect?: Schedule.Schedule<unknown> | false
-}): Effect.Effect<globalThis.WebSocket, WebSocketError, Scope.Scope> =>
+}): Effect.Effect<globalThis.WebSocket, WebSocketError, Scope.Scope | HttpClient.HttpClient> =>
   Effect.gen(function* () {
-    const socket = yield* Effect.tryPromise({
-      try: async () => {
-        // console.debug('[WebSocket] connecting to', url)
+    yield* validateUrl(url)
+
+    const socket = yield* Effect.async<globalThis.WebSocket, WebSocketError>((cb, signal) => {
+      try {
         const socket = new globalThis.WebSocket(url)
 
         if (socket.readyState === globalThis.WebSocket.OPEN) {
-          return socket
+          cb(Effect.succeed(socket))
+          return
         }
 
-        return await new Promise<globalThis.WebSocket>((resolve, reject) => {
-          socket.addEventListener('open', () => resolve(socket), { once: true })
-          // eslint-disable-next-line unicorn/prefer-add-event-listener
-          socket.onerror = (event) => reject(event)
+        signal.addEventListener('abort', () => {
+          socket.close(3000, 'abort signal')
         })
-      },
-      catch: (errorEvent: any) => {
-        if (errorEvent.currentTarget != null && errorEvent.currentTarget instanceof globalThis.WebSocket) {
-          errorEvent.currentTarget.close(3000, `closing websocket connection due to error: ${errorEvent.toString()}`)
-        }
 
-        return new WebSocketError({ cause: errorEvent })
-      },
+        socket.addEventListener('open', () => cb(Effect.succeed(socket)), { once: true })
+
+        socket.addEventListener(
+          'error',
+          (event) => {
+            cb(Effect.fail(new WebSocketError({ cause: event })))
+          },
+          { once: true },
+        )
+
+        socket.addEventListener(
+          'close',
+          (event) => {
+            // console.log('makeWebSocket:socket:onclose', event)
+            return cb(Effect.fail(new WebSocketError({ cause: event })))
+          },
+          { once: true },
+        )
+
+        // console.log('makeWebSocket:socket:waiting for open', url)
+      } catch (error) {
+        cb(Effect.fail(new WebSocketError({ cause: error })))
+      }
     }).pipe(
-      /**
-       * Common WebSocket close codes: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
-       *   1000: Normal closure
-       *   1001: Endpoint is going away, a server is terminating the connection because it has received a request that indicates the client is ending the connection.
-       *   1002: Protocol error, a server is terminating the connection because it has received data on the connection that was not consistent with the type of the connection.
-       *   1011: Internal server error, a server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
-       *
-       * For reference, here are the valid WebSocket close code ranges:
-       *   1000-1999: Reserved for protocol usage
-       *   2000-2999: Reserved for WebSocket extensions
-       *   3000-3999: Available for libraries and frameworks
-       *   4000-4999: Available for applications
-       */
-      Effect.acquireRelease((socket, exit) =>
-        Effect.sync(() =>
-          Exit.isFailure(exit)
-            ? socket.close(3000, `closing webmesh websocket connection due to error: ${exit.cause.toString()}`)
-            : socket.close(1000, 'closing webmesh websocket connection gracefully'),
-        ),
-      ),
+      Effect.tapErrorTag('WebSocketError', () => tryLogWebsocketConnectError(url)),
       reconnect ? Effect.retry(reconnect) : identity,
     )
 
+    /**
+     * Common WebSocket close codes: https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/close
+     *   1000: Normal closure
+     *   1001: Endpoint is going away, a server is terminating the connection because it has received a request that indicates the client is ending the connection.
+     *   1002: Protocol error, a server is terminating the connection because it has received data on the connection that was not consistent with the type of the connection.
+     *   1011: Internal server error, a server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.
+     *
+     * For reference, here are the valid WebSocket close code ranges:
+     *   1000-1999: Reserved for protocol usage
+     *   2000-2999: Reserved for WebSocket extensions
+     *   3000-3999: Available for libraries and frameworks
+     *   4000-4999: Available for applications
+     */
+    yield* Effect.addFinalizer(
+      Effect.fn(function* (exit) {
+        try {
+          if (Exit.isFailure(exit)) {
+            socket.close(3000)
+          } else {
+            socket.close(1000)
+          }
+        } catch (error) {
+          yield* Effect.die(new WebSocketError({ cause: error }))
+        }
+      }),
+    )
+
     return socket
   })
+
+const validateUrl = (url: string) =>
+  Effect.try({
+    try: () => new URL(url),
+    catch: (error) => new WebSocketError({ cause: error }),
+  })
+
+const tryLogWebsocketConnectError = (url: string) =>
+  Effect.gen(function* () {
+    const client = yield* HttpClient.HttpClient
+    const res = yield* client.get(url)
+    const responseBody = yield* res.text
+    yield* Effect.logError(`Failed to connect to '${url}' (status: ${res.status}). Error:`, responseBody)
+  }).pipe(Effect.ignore)

package/src/effect/index.ts

@@ -37,6 +37,7 @@ export {
   SortedMap,
   HashMap,
   HashSet,
+  ManagedRuntime,
   MutableHashSet,
   MutableHashMap,
   TQueue,
@@ -56,8 +57,14 @@ export {
   Match,
   TestServices,
   Mailbox,
+  ExecutionStrategy,
+  PrimaryKey,
+  Types,
+  Cache,
 } from 'effect'
 
+export * as StandardSchema from '@standard-schema/spec'
+
 export { dual } from 'effect/Function'
 
 export * as Stream from './Stream.js'
@@ -69,7 +76,7 @@ export * as Subscribable from './Subscribable.js'
 
 export * as Logger from './Logger.js'
 
-export * as WebChannel from './WebChannel.js'
+export * as WebChannel from './WebChannel/mod.js'
 export * as WebSocket from './WebSocket.js'
 
 export * as SchemaAST from 'effect/SchemaAST'
@@ -78,9 +85,21 @@ export { ParseResult, Pretty } from 'effect'
 export type { Serializable, SerializableWithResult } from 'effect/Schema'
 export * as Schema from './Schema/index.js'
 export * as OtelTracer from '@effect/opentelemetry/Tracer'
-// export * as OtelResource from '@effect/opentelemetry/Resource'
 export * as TaskTracing from './TaskTracing.js'
 
+export {
+  Rpc,
+  RpcGroup,
+  RpcClient,
+  RpcMessage,
+  RpcSchema,
+  RpcMiddleware,
+  RpcServer,
+  RpcSerialization,
+  RpcTest,
+  RpcWorker,
+} from '@effect/rpc'
+
 export {
   Transferable,
   FileSystem,
@@ -95,6 +114,16 @@ export {
   HttpClientResponse,
   FetchHttpClient,
   Socket,
+  UrlParams,
+  HttpServerRequest,
+  Headers,
+  HttpMiddleware,
+  HttpRouter,
+  HttpServerResponse,
+  Command,
+  CommandExecutor,
+  KeyValueStore,
+  Error as PlatformError,
 } from '@effect/platform'
 export { BrowserWorker, BrowserWorkerRunner } from '@effect/platform-browser'
 

package/src/env.ts

@@ -1,3 +1,5 @@
+import { envTruish } from './misc.js'
+
 export const env = (name: string): string | undefined => {
   if (typeof process !== 'undefined' && process.env !== undefined) {
     return process.env[name]
@@ -12,20 +14,14 @@ export const env = (name: string): string | undefined => {
   return undefined
 }
 
-export const isDevEnv = () => {
-  if (typeof process !== 'undefined' && process.env !== undefined) {
-    return process.env.NODE_ENV !== 'production'
-  }
+// export const TRACE_VERBOSE = true
+export const TRACE_VERBOSE = env('LS_TRACE_VERBOSE') !== undefined || env('VITE_LS_TRACE_VERBOSE') !== undefined
 
-  // TODO re-enable the full guard code once `import.meta` is supported in Expo
-  // if (import.meta !== undefined && import.meta.env !== undefined) {
-  if (import.meta.env !== undefined) {
-    return import.meta.env.DEV
-  }
+/** Only set when developing LiveStore itself. */
+export const LS_DEV = envTruish(env('LS_DEV')) || envTruish(env('VITE_LS_DEV'))
 
-  return false
-}
+export const IS_CI = envTruish(env('CI'))
 
-export const TRACE_VERBOSE = env('LS_TRACE_VERBOSE') !== undefined || env('VITE_LS_TRACE_VERBOSE') !== undefined
+export const IS_BUN = typeof Bun !== 'undefined'
 
-export const LS_DEV = env('LS_DEV') !== undefined || env('VITE_LS_DEV') !== undefined
+export const IS_REACT_NATIVE = typeof navigator !== 'undefined' && navigator.product === 'ReactNative'

package/src/index.ts

@@ -14,12 +14,11 @@ export * as base64 from './base64.js'
 export { default as prettyBytes } from 'pretty-bytes'
 
 import type * as otel from '@opentelemetry/api'
+import type { Types } from 'effect'
 
-import { isDevEnv } from './env.js'
 import { objectToString } from './misc.js'
 
 export type Prettify<T> = T extends infer U ? { [K in keyof U]: Prettify<U[K]> } : never
-export type PrettifyFlat<T> = T extends infer U ? { [K in keyof U]: U[K] } : never
 
 export type TypeEq<A, B> = (<T>() => T extends A ? 1 : 2) extends <T>() => T extends B ? 1 : 2 ? true : false
 
@@ -30,12 +29,16 @@ export type AssertTrue<T extends true> = T
 export type Writeable<T> = { -readonly [P in keyof T]: T[P] }
 export type DeepWriteable<T> = { -readonly [P in keyof T]: DeepWriteable<T[P]> }
 
+export type Nullable<T> = { [K in keyof T]: T[K] | null }
+
 export type Primitive = null | undefined | string | number | boolean | symbol | bigint
 
 export type LiteralUnion<LiteralType, BaseType extends Primitive> = LiteralType | (BaseType & Record<never, never>)
 
 export type GetValForKey<T, K> = K extends keyof T ? T[K] : never
 
+export type SingleOrReadonlyArray<T> = T | ReadonlyArray<T>
+
 export const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))
 
 export const ref = <T>(val: T): { current: T } => ({ current: val })
@@ -88,15 +91,6 @@ export function casesHandled(unexpectedCase: never): never {
   throw new Error(`A case was not handled for value: ${truncate(objectToString(unexpectedCase), 1000)}`)
 }
 
-export const shouldNeverHappen = (msg?: string, ...args: any[]): never => {
-  console.error(msg, ...args)
-  if (isDevEnv()) {
-    debugger
-  }
-
-  throw new Error(`This should never happen: ${msg}`)
-}
-
 export const assertNever = (failIfFalse: boolean, msg?: string): void => {
   if (failIfFalse === false) {
     debugger
@@ -134,7 +128,7 @@ export const unwrapThunk = <T>(_: T | (() => T)): T => {
   }
 }
 
-export type NullableFieldsToOptional<T> = PrettifyFlat<
+export type NullableFieldsToOptional<T> = Types.Simplify<
   Partial<T> & {
     [K in keyof T as null extends T[K] ? K : never]?: Exclude<T[K], null>
   } & {

package/src/misc.ts

@@ -1,3 +1,22 @@
+export const isDevEnv = () => {
+  if (typeof process !== 'undefined' && process.env !== undefined) {
+    return process.env.NODE_ENV !== 'production'
+  }
+
+  // TODO re-enable the full guard code once `import.meta` is supported in Expo
+  // if (import.meta !== undefined && import.meta.env !== undefined) {
+  if (import.meta.env !== undefined) {
+    return import.meta.env.DEV
+  }
+
+  // @ts-expect-error Only exists in Expo / RN
+  if (typeof globalThis !== 'undefined' && globalThis.__DEV__) {
+    return true
+  }
+
+  return false
+}
+
 export const objectToString = (error: any): string => {
   const str = error?.toString()
   if (str !== '[object Object]') return str
@@ -24,3 +43,15 @@ export const tryAsFunctionAndNew = <TArg, TResult>(
     return fnOrConstructor(arg)
   }
 }
+
+export const envTruish = (env: string | undefined) =>
+  env !== undefined && env.toLowerCase() !== 'false' && env.toLowerCase() !== '0'
+
+export const shouldNeverHappen = (msg?: string, ...args: any[]): never => {
+  console.error(msg, ...args)
+  if (isDevEnv()) {
+    debugger
+  }
+
+  throw new Error(`This should never happen: ${msg}`)
+}

package/src/node/ChildProcessRunner/ChildProcessRunner.ts

@@ -2,8 +2,9 @@
 import process from 'node:process'
 
 import { WorkerError } from '@effect/platform/WorkerError'
+import type { CloseLatch } from '@effect/platform/WorkerRunner'
 import * as Runner from '@effect/platform/WorkerRunner'
-import { FiberId } from 'effect'
+import * as Cause from 'effect/Cause'
 import * as Context from 'effect/Context'
 import * as Deferred from 'effect/Deferred'
 import * as Effect from 'effect/Effect'
@@ -15,7 +16,7 @@ import * as Scope from 'effect/Scope'
 
 const platformRunnerImpl = Runner.PlatformRunner.of({
   [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
-  start<I, O>() {
+  start<I, O>(closeLatch: typeof CloseLatch.Service) {
     return Effect.gen(function* () {
       if (!process.send) {
         return yield* new WorkerError({ reason: 'spawn', cause: new Error('not in a child process') })
@@ -27,37 +28,47 @@ const platformRunnerImpl = Runner.PlatformRunner.of({
       }
       const send = (_portId: number, message: O, _transfers?: ReadonlyArray<unknown>) =>
         Effect.sync(() => port.postMessage([1, message] /*, transfers as any*/))
-      const run = <A, E, R>(handler: (portId: number, message: I) => Effect.Effect<A, E, R>) =>
-        Effect.uninterruptibleMask((restore) =>
-          Effect.gen(function* () {
-            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)
-            port.on('message', (message: Runner.BackingRunner.Message<I>) => {
-              if (message[0] === 0) {
-                FiberSet.unsafeAdd(fiberSet, runFork(restore(handler(0, message[1]))))
-              } else {
-                Deferred.unsafeDone(fiberSet.deferred, Exit.interrupt(FiberId.none))
-                port.close()
-              }
-            })
-            port.on('messageerror', (cause) => {
-              Deferred.unsafeDone(fiberSet.deferred, new WorkerError({ reason: 'decode', cause }))
-            })
-            port.on('error', (cause) => {
-              Deferred.unsafeDone(fiberSet.deferred, new WorkerError({ reason: 'unknown', cause }))
-            })
-            port.postMessage([0])
-            return (yield* restore(FiberSet.join(fiberSet))) as never
-          }).pipe(Effect.scoped),
-        )
+
+      const run = Effect.fnUntraced(function* <A, E, R>(
+        handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void,
+      ) {
+        const runtime = (yield* Effect.interruptible(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)
+        const onExit = (exit: Exit.Exit<any, E>) => {
+          if (exit._tag === 'Failure' && !Cause.isInterruptedOnly(exit.cause)) {
+            // Deferred.unsafeDone(closeLatch, Exit.die(Cause.squash(exit.cause)))
+            Deferred.unsafeDone(closeLatch, Exit.die(exit.cause))
+          }
+        }
+        port.on('message', (message: Runner.BackingRunner.Message<I>) => {
+          // console.log('message', message)
+          if (message[0] === 0) {
+            const result = handler(0, message[1])
+            if (Effect.isEffect(result)) {
+              const fiber = runFork(result)
+              fiber.addObserver(onExit)
+              FiberSet.unsafeAdd(fiberSet, fiber)
+            }
+          } else {
+            Deferred.unsafeDone(closeLatch, Exit.void)
+            port.close()
+          }
+        })
+        port.on('messageerror', (cause) => {
+          Deferred.unsafeDone(closeLatch, new WorkerError({ reason: 'decode', cause }))
+        })
+        port.on('error', (cause) => {
+          Deferred.unsafeDone(closeLatch, new WorkerError({ reason: 'unknown', cause }))
+        })
+        port.postMessage([0])
+      })
 
       return { run, send }
     })
   },
 })
 
-/** @internal */
 export const layer = Layer.succeed(Runner.PlatformRunner, platformRunnerImpl)

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/ChildProcessRunner.test.ts

@@ -0,0 +1,52 @@
+// import * as WorkerThreads from 'node:worker_threads'
+import * as ChildProcess from 'node:child_process'
+
+import * as EffectWorker from '@effect/platform/Worker'
+import { assert, describe, it } from '@effect/vitest'
+import { Chunk, Effect, Stream } from 'effect'
+
+import * as ChildProcessWorker from '../ChildProcessWorker.js'
+import type { WorkerMessage } from './schema.js'
+import { GetPersonById, GetUserById, InitialMessage, Person, User } from './schema.js'
+
+const WorkerLive = ChildProcessWorker.layer(() =>
+  ChildProcess.fork(
+    new URL('../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js', import.meta.url),
+  ),
+)
+
+// const WorkerLive = NodeWorker.layer(
+//   () =>
+//     new WorkerThreads.Worker(
+//       new URL('../../../../dist/node/ChildProcessRunner/ChildProcessRunnerTest/serializedWorker.js', import.meta.url),
+//     ),
+// )
+
+describe('ChildProcessRunner', { timeout: 10_000 }, () => {
+  it('Serialized', () =>
+    Effect.gen(function* () {
+      const pool = yield* EffectWorker.makePoolSerialized({ size: 1 })
+      const people = yield* pool.execute(new GetPersonById({ id: 123 })).pipe(Stream.runCollect)
+      assert.deepStrictEqual(Chunk.toReadonlyArray(people), [
+        new Person({ id: 123, name: 'test', data: new Uint8Array([1, 2, 3]) }),
+        new Person({ id: 123, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
+      ])
+    }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
+
+  it('Serialized with initialMessage', () =>
+    Effect.gen(function* () {
+      const pool = yield* EffectWorker.makePoolSerialized<WorkerMessage>({
+        size: 1,
+        initialMessage: () => new InitialMessage({ name: 'custom', data: new Uint8Array([1, 2, 3]) }),
+      })
+
+      let user = yield* pool.executeEffect(new GetUserById({ id: 123 }))
+      user = yield* pool.executeEffect(new GetUserById({ id: 123 }))
+      assert.deepStrictEqual(user, new User({ id: 123, name: 'custom' }))
+      const people = yield* pool.execute(new GetPersonById({ id: 123 })).pipe(Stream.runCollect)
+      assert.deepStrictEqual(Chunk.toReadonlyArray(people), [
+        new Person({ id: 123, name: 'test', data: new Uint8Array([1, 2, 3]) }),
+        new Person({ id: 123, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
+      ])
+    }).pipe(Effect.scoped, Effect.provide(WorkerLive), Effect.runPromise))
+})

package/src/node/ChildProcessRunner/ChildProcessRunnerTest/schema.ts

@@ -0,0 +1,65 @@
+// import * as Transferable from '@effect/platform/Transferable'
+import * as Schema from 'effect/Schema'
+
+export class User extends Schema.Class<User>('User')({
+  id: Schema.Number,
+  name: Schema.String,
+}) {}
+
+export class GetUserById extends Schema.TaggedRequest<GetUserById>()('GetUserById', {
+  failure: Schema.Never,
+  success: User,
+  payload: {
+    id: Schema.Number,
+  },
+}) {}
+
+export class Person extends Schema.Class<Person>('Person')({
+  id: Schema.Number,
+  name: Schema.String,
+  // data: Transferable.Uint8Array,
+  data: Schema.Uint8Array,
+}) {}
+
+export class GetPersonById extends Schema.TaggedRequest<GetPersonById>()('GetPersonById', {
+  failure: Schema.Never,
+  success: Person,
+  payload: {
+    id: Schema.Number,
+  },
+}) {}
+
+export class RunnerInterrupt extends Schema.TaggedRequest<RunnerInterrupt>()('RunnerInterrupt', {
+  failure: Schema.Never,
+  success: Schema.Void,
+  payload: {},
+}) {}
+
+export class InitialMessage extends Schema.TaggedRequest<InitialMessage>()('InitialMessage', {
+  failure: Schema.Never,
+  success: Schema.Void,
+  payload: {
+    name: Schema.String,
+    data: Schema.Uint8Array,
+    // data: Transferable.Uint8Array,
+  },
+}) {}
+
+export class GetSpan extends Schema.TaggedRequest<GetSpan>()('GetSpan', {
+  failure: Schema.Never,
+  success: Schema.Struct({
+    name: Schema.String,
+    traceId: Schema.String,
+    spanId: Schema.String,
+    parent: Schema.Option(
+      Schema.Struct({
+        traceId: Schema.String,
+        spanId: Schema.String,
+      }),
+    ),
+  }),
+  payload: {},
+}) {}
+
+export const WorkerMessage = Schema.Union(GetUserById, GetPersonById, InitialMessage, GetSpan, RunnerInterrupt)
+export type WorkerMessage = Schema.Schema.Type<typeof WorkerMessage>