@livestore/utils 0.3.0-dev.2 → 0.3.0-dev.20

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,52 @@ 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 schemaWithDebugPing = <MsgListen, MsgSend>(
+  schema: OutputSchema<MsgListen, MsgSend, any, any>,
+): OutputSchema<MsgListen | typeof DebugPingMessage.Type, MsgSend | typeof DebugPingMessage.Type, any, any> => ({
+  send: Schema.Union(schema.send, DebugPingMessage),
+  listen: Schema.Union(schema.listen, DebugPingMessage),
+})
+
+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')
+    ? (schemaWithDebugPing(schema) as any)
+    : (schemaWithDebugPing({ 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,14 @@
+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)
+    }),
+  )
+})

package/src/effect/WebSocket.ts

@@ -22,51 +22,78 @@ export const makeWebSocket = ({
   reconnect?: Schedule.Schedule<unknown> | false
 }): Effect.Effect<globalThis.WebSocket, WebSocketError, Scope.Scope> =>
   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 })
-      },
-    }).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'),
-        ),
-      ),
-      reconnect ? Effect.retry(reconnect) : identity,
+        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(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((exit) =>
+      Effect.async<void, WebSocketError>((cb) => {
+        try {
+          if (Exit.isFailure(exit)) {
+            socket.close(3000)
+          } else {
+            socket.close(1000)
+          }
+        } catch (error) {
+          cb(Effect.fail(new WebSocketError({ cause: error })))
+        }
+      }).pipe(Effect.orDie),
     )
 
     return socket
   })
+
+const validateUrl = (url: string) =>
+  Effect.try({
+    try: () => new URL(url),
+    catch: (error) => new WebSocketError({ cause: error }),
+  })

package/src/effect/index.ts

@@ -49,13 +49,21 @@ export {
   TRef,
   Channel,
   Predicate,
+  // Subscribable,
   pipe,
   identity,
   GlobalValue,
   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'
@@ -63,10 +71,11 @@ export * as Stream from './Stream.js'
 export * as BucketQueue from './BucketQueue.js'
 
 export * as SubscriptionRef from './SubscriptionRef.js'
+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'

package/src/env.ts

@@ -26,6 +26,11 @@ export const isDevEnv = () => {
   return false
 }
 
+// export const TRACE_VERBOSE = true
 export const TRACE_VERBOSE = env('LS_TRACE_VERBOSE') !== undefined || env('VITE_LS_TRACE_VERBOSE') !== undefined
 
 export const LS_DEV = env('LS_DEV') !== undefined || env('VITE_LS_DEV') !== undefined
+
+const envTruish = (env: string | undefined) => env !== undefined && env !== 'false' && env !== '0'
+
+export const IS_CI = envTruish(env('CI'))

package/src/index.ts

@@ -14,12 +14,12 @@ 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,6 +30,8 @@ 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>)
@@ -134,7 +136,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/node/ChildProcessRunner/ChildProcessRunner.ts

@@ -3,7 +3,6 @@ import process from 'node:process'
 
 import { WorkerError } from '@effect/platform/WorkerError'
 import * as Runner from '@effect/platform/WorkerRunner'
-import { FiberId } from 'effect'
 import * as Context from 'effect/Context'
 import * as Deferred from 'effect/Deferred'
 import * as Effect from 'effect/Effect'
@@ -15,7 +14,7 @@ import * as Scope from 'effect/Scope'
 
 const platformRunnerImpl = Runner.PlatformRunner.of({
   [Runner.PlatformRunnerTypeId]: Runner.PlatformRunnerTypeId,
-  start<I, O>() {
+  start<I, O>(closeLatch: Deferred.Deferred<void, WorkerError>) {
     return Effect.gen(function* () {
       if (!process.send) {
         return yield* new WorkerError({ reason: 'spawn', cause: new Error('not in a child process') })
@@ -27,37 +26,44 @@ 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>,
+      ) {
+        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') {
+            // 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 fiber = runFork(handler(0, message[1]))
+            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>

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

@@ -0,0 +1,53 @@
+import * as Runner from '@effect/platform/WorkerRunner'
+import { Context, Effect, Layer, Option, Stream } from 'effect'
+
+// import { NodeRuntime, NodeWorkerRunner } from '@effect/platform-node'
+import { PlatformNode } from '../../mod.js'
+import * as ChildProcessRunner from '../ChildProcessRunner.js'
+import { Person, User, WorkerMessage } from './schema.js'
+
+interface Name {
+  readonly _: unique symbol
+}
+const Name = Context.GenericTag<Name, string>('Name')
+
+const WorkerLive = Runner.layerSerialized(WorkerMessage, {
+  GetPersonById: (req) => {
+    return Stream.make(
+      new Person({ id: req.id, name: 'test', data: new Uint8Array([1, 2, 3]) }),
+      new Person({ id: req.id, name: 'ing', data: new Uint8Array([4, 5, 6]) }),
+    )
+  },
+  GetUserById: (req) => Effect.map(Name, (name) => new User({ id: req.id, name })),
+  // InitialMessage: (req) => Layer.succeed(Name, req.name),
+  InitialMessage: (req) =>
+    Effect.gen(function* () {
+      yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
+      return Layer.succeed(Name, req.name)
+    }).pipe(Layer.unwrapScoped),
+  // InitialMessage: (req) =>
+  //   Layer.scoped(
+  //     Name,
+  //     Effect.gen(function* () {
+  //       yield* Effect.addFinalizer(() => Effect.log('closing worker scope'))
+  //       return req.name
+  //     }),
+  //   ),
+  GetSpan: (_) =>
+    Effect.gen(function* (_) {
+      const span = yield* _(Effect.currentSpan, Effect.orDie)
+      return {
+        traceId: span.traceId,
+        spanId: span.spanId,
+        name: span.name,
+        parent: Option.map(span.parent, (span) => ({
+          traceId: span.traceId,
+          spanId: span.spanId,
+        })),
+      }
+    }).pipe(Effect.withSpan('GetSpan')),
+  RunnerInterrupt: () => Effect.interrupt,
+}).pipe(Layer.provide(ChildProcessRunner.layer))
+// }).pipe(Layer.provide(PlatformNode.NodeWorkerRunner.layer))
+
+PlatformNode.NodeRuntime.runMain(Runner.launch(WorkerLive))

package/src/node/ChildProcessRunner/ChildProcessWorker.ts

@@ -1,9 +1,9 @@
 /* eslint-disable prefer-arrow/prefer-arrow-functions */
 
-import type * as ChildProcess from 'node:child_process'
-
 import * as Worker from '@effect/platform/Worker'
 import { WorkerError } from '@effect/platform/WorkerError'
+// eslint-disable-next-line unicorn/prefer-node-protocol
+import type * as ChildProcess from 'child_process'
 import * as Deferred from 'effect/Deferred'
 import * as Effect from 'effect/Effect'
 import * as Exit from 'effect/Exit'
@@ -23,8 +23,8 @@ const platformWorkerImpl = Worker.makePlatform<ChildProcess.ChildProcess>()({
             childProcess.send([1])
             return Deferred.await(exitDeferred)
           }).pipe(
-            Effect.interruptible,
             Effect.timeout(5000),
+            Effect.interruptible,
             Effect.catchAllCause(() => Effect.sync(() => childProcess.kill())),
           ),
         ),
@@ -55,12 +55,9 @@ const platformWorkerImpl = Worker.makePlatform<ChildProcess.ChildProcess>()({
   },
 })
 
-/** @internal */
 export const layerWorker = Layer.succeed(Worker.PlatformWorker, platformWorkerImpl)
 
-/** @internal */
 export const layerManager = Layer.provide(Worker.layerManager, layerWorker)
 
-/** @internal */
 export const layer = (spawn: (id: number) => ChildProcess.ChildProcess) =>
   Layer.merge(layerManager, Worker.layerSpawner(spawn))