@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 103 lines 3.8 KB
Raw
1 /**
2 * Worker-entrypoint support for Bun worker runners.
3 *
4 * This module exports a `layer` that provides `WorkerRunnerPlatform` for code
5 * already running inside a Bun `Worker`. The platform receives request messages
6 * from the parent-side `BunWorker` platform, runs the registered handler, sends
7 * responses through the worker `postMessage` channel, and closes when the
8 * parent sends the close message.
9 *
10 * @stability unstable
11 * @since 4.0.0
12 */
13 import * as Cause from "effect/Cause"
14 import * as Deferred from "effect/Deferred"
15 import * as Effect from "effect/Effect"
16 import * as Exit from "effect/Exit"
17 import * as Fiber from "effect/Fiber"
18 import { identity } from "effect/Function"
19 import * as Layer from "effect/Layer"
20 import * as Scope from "effect/Scope"
21 import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/workers/WorkerError"
22 import * as WorkerRunner from "effect/workers/WorkerRunner"
23
24 declare const self: MessagePort
25
26 /**
27 * Provides the `WorkerRunnerPlatform` for code running inside a Bun worker,
28 * routing parent messages to the registered handler and sending responses back
29 * through the worker port.
30 *
31 * @stability unstable
32 * @category layers
33 * @since 4.0.0
34 */
35 export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
36 start: Effect.fnUntraced(function*<O = unknown, I = unknown>() {
37 if (!("postMessage" in self)) {
38 return yield* new WorkerError({
39 reason: new WorkerSpawnError({ message: "not in a Worker context" })
40 })
41 }
42 const port = self
43 const run = <A, E, R>(
44 handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void
45 ) =>
46 Effect.scopedWith(Effect.fnUntraced(function*(scope) {
47 const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
48 const trackFiber = Fiber.runIn(scope)
49 const services = yield* Effect.context<R>()
50 const runFork = Effect.runForkWith(services)
51 const onExit = (exit: Exit.Exit<any, E>) => {
52 if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
53 runFork(Effect.logError("unhandled error in worker", exit.cause))
54 }
55 }
56
57 function onMessage(event: MessageEvent) {
58 const message = (event as MessageEvent).data as WorkerRunner.PlatformMessage<I>
59 if (message[0] === 0) {
60 const result = handler(0, message[1])
61 if (Effect.isEffect(result)) {
62 const fiber = runFork(result)
63 fiber.addObserver(onExit)
64 trackFiber(fiber)
65 }
66 } else {
67 Deferred.doneUnsafe(closeLatch, Exit.void)
68 }
69 }
70 function onMessageError(error: MessageEvent) {
71 Deferred.doneUnsafe(
72 closeLatch,
73 new WorkerError({
74 reason: new WorkerReceiveError({
75 message: "received messageerror event",
76 cause: error.data
77 })
78 })
79 )
80 }
81 yield* Scope.addFinalizer(
82 scope,
83 Effect.sync(() => {
84 port.removeEventListener("message", onMessage)
85 port.removeEventListener("messageerror", onMessageError)
86 })
87 )
88 port.addEventListener("message", onMessage)
89 port.addEventListener("messageerror", onMessageError)
90 port.postMessage([0])
91
92 return yield* Deferred.await(closeLatch)
93 }))
94
95 const sendUnsafe = (_portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
96 port.postMessage([1, message], {
97 transfer: transfer as any
98 })
99 const send = (_portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
100 Effect.sync(() => sendUnsafe(0, message, transfer))
101 return identity<WorkerRunner.WorkerRunner<any, any>>({ run, send, sendUnsafe })
102 })
103 })