@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 95 lines 2.9 KB
Raw
1 /**
2 * Parent-side worker support for Bun applications.
3 *
4 * `layerPlatform` provides the `WorkerPlatform` used to communicate with
5 * `globalThis.Worker` instances through Effect's worker protocol. `layer`
6 * combines that platform with a `Spawner` built from a callback that creates a
7 * worker for each worker id. The platform forwards worker messages and errors,
8 * asks workers to close on scope finalization, and terminates them if graceful
9 * shutdown times out.
10 *
11 * @stability unstable
12 * @since 4.0.0
13 */
14 import * as Deferred from "effect/Deferred"
15 import * as Effect from "effect/Effect"
16 import * as Exit from "effect/Exit"
17 import * as Layer from "effect/Layer"
18 import * as Scope from "effect/Scope"
19 import * as Worker from "effect/workers/Worker"
20 import { WorkerError, WorkerUnknownError } from "effect/workers/WorkerError"
21
22 /**
23 * Provides the Bun `WorkerPlatform` together with a `Worker.Spawner` created
24 * from the supplied worker spawning function.
25 *
26 * @stability unstable
27 * @category layers
28 * @since 4.0.0
29 */
30 export const layer = (
31 spawn: (id: number) => globalThis.Worker
32 ): Layer.Layer<Worker.WorkerPlatform | Worker.Spawner> =>
33 Layer.merge(
34 layerPlatform,
35 Layer.succeed(Worker.Spawner)(spawn)
36 )
37
38 /**
39 * Provides the Bun `WorkerPlatform`, wiring worker messages and errors into
40 * Effect workers and requesting graceful worker shutdown during scope
41 * finalization before terminating on timeout.
42 *
43 * @stability unstable
44 * @category layers
45 * @since 4.0.0
46 */
47 export const layerPlatform = Layer.succeed(Worker.WorkerPlatform)(
48 Worker.makePlatform<globalThis.Worker>()({
49 setup({ scope, worker }) {
50 const closeDeferred = Deferred.makeUnsafe<void>()
51 worker.addEventListener("close", () => {
52 Deferred.doneUnsafe(closeDeferred, Exit.void)
53 })
54 return Effect.as(
55 Scope.addFinalizer(
56 scope,
57 Effect.suspend(() => {
58 worker.postMessage([1])
59 return Deferred.await(closeDeferred)
60 }).pipe(
61 Effect.interruptible,
62 Effect.timeout(5000),
63 Effect.catchCause(() => Effect.sync(() => worker.terminate()))
64 )
65 ),
66 worker
67 )
68 },
69 listen({ deferred, emit, port, scope }) {
70 function onMessage(event: MessageEvent) {
71 emit(event.data)
72 }
73 function onError(event: ErrorEvent) {
74 Deferred.doneUnsafe(
75 deferred,
76 new WorkerError({
77 reason: new WorkerUnknownError({
78 message: "An error event was emitted",
79 cause: event.error ?? event.message
80 })
81 })
82 )
83 }
84 port.addEventListener("message", onMessage)
85 port.addEventListener("error", onError)
86 return Scope.addFinalizer(
87 scope,
88 Effect.sync(() => {
89 port.removeEventListener("message", onMessage)
90 port.removeEventListener("error", onError)
91 })
92 )
93 }
94 })
95 )