@smthrs/platform-bun 0.0.0-stage → 1.0.0-rc.13

package/dist/vendor/chunk-4O4Z52A2.js

@@ -0,0 +1,48 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.5_effect@4.0.5/node_modules/@effect/platform-node-shared/dist/NodeCrypto.js
+var NodeCrypto_exports = {};
+__export(NodeCrypto_exports, {
+  layer: () => layer,
+  make: () => make2
+});
+import * as EffectCrypto from "effect/Crypto";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as PlatformError from "effect/PlatformError";
+import * as NodeCrypto from "node:crypto";
+var toHashAlgorithm = (algorithm) => {
+  switch (algorithm) {
+    case "SHA-1":
+      return "sha1";
+    case "SHA-256":
+      return "sha256";
+    case "SHA-384":
+      return "sha384";
+    case "SHA-512":
+      return "sha512";
+  }
+};
+var digest = (algorithm, data) => Effect.try({
+  try: () => Uint8Array.from(NodeCrypto.createHash(toHashAlgorithm(algorithm)).update(data).digest()),
+  catch: (cause) => PlatformError.systemError({
+    module: "Crypto",
+    method: "digest",
+    _tag: "Unknown",
+    description: "Could not compute digest",
+    cause
+  })
+});
+var make2 = /* @__PURE__ */ EffectCrypto.make({
+  randomBytes: NodeCrypto.randomBytes,
+  digest
+});
+var layer = /* @__PURE__ */ Layer.succeed(EffectCrypto.Crypto, make2);
+
+export {
+  make2 as make,
+  layer,
+  NodeCrypto_exports
+};

package/dist/vendor/chunk-4YK2MHSO.js

@@ -0,0 +1,20 @@
+import {
+  fromSocket,
+  layer,
+  make
+} from "./chunk-TCKM3JXD.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeDatagramSocket.js
+var NodeDatagramSocket_exports = {};
+__export(NodeDatagramSocket_exports, {
+  fromSocket: () => fromSocket,
+  layer: () => layer,
+  make: () => make
+});
+
+export {
+  NodeDatagramSocket_exports
+};

package/dist/vendor/chunk-6B775XB2.js

@@ -0,0 +1,85 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.5_effect@4.0.5/node_modules/@effect/platform-bun/dist/BunWorkerRunner.js
+var BunWorkerRunner_exports = {};
+__export(BunWorkerRunner_exports, {
+  layer: () => layer
+});
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { identity } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/workers/WorkerError";
+import * as WorkerRunner from "effect/workers/WorkerRunner";
+var layer = /* @__PURE__ */ Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start: /* @__PURE__ */ Effect.fnUntraced(function* () {
+    if (!("postMessage" in self)) {
+      return yield* new WorkerError({
+        reason: new WorkerSpawnError({
+          message: "not in a Worker context"
+        })
+      });
+    }
+    const port = self;
+    const run = (handler) => Effect.scopedWith(Effect.fnUntraced(function* (scope) {
+      const closeLatch = Deferred.makeUnsafe();
+      const trackFiber = Fiber.runIn(scope);
+      const services = yield* Effect.context();
+      const runFork = Effect.runForkWith(services);
+      const onExit = (exit) => {
+        if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+          runFork(Effect.logError("unhandled error in worker", exit.cause));
+        }
+      };
+      function onMessage(event) {
+        const message = event.data;
+        if (message[0] === 0) {
+          const result = handler(0, message[1]);
+          if (Effect.isEffect(result)) {
+            const fiber = runFork(result);
+            fiber.addObserver(onExit);
+            trackFiber(fiber);
+          }
+        } else {
+          Deferred.doneUnsafe(closeLatch, Exit.void);
+        }
+      }
+      function onMessageError(error) {
+        Deferred.doneUnsafe(closeLatch, new WorkerError({
+          reason: new WorkerReceiveError({
+            message: "received messageerror event",
+            cause: error.data
+          })
+        }));
+      }
+      yield* Scope.addFinalizer(scope, Effect.sync(() => {
+        port.removeEventListener("message", onMessage);
+        port.removeEventListener("messageerror", onMessageError);
+      }));
+      port.addEventListener("message", onMessage);
+      port.addEventListener("messageerror", onMessageError);
+      port.postMessage([0]);
+      return yield* Deferred.await(closeLatch);
+    }));
+    const sendUnsafe = (_portId, message, transfer) => port.postMessage([1, message], {
+      transfer
+    });
+    const send = (_portId, message, transfer) => Effect.sync(() => sendUnsafe(0, message, transfer));
+    return identity({
+      run,
+      send,
+      sendUnsafe
+    });
+  })
+});
+
+export {
+  layer,
+  BunWorkerRunner_exports
+};

package/dist/vendor/chunk-6KYVM2ZC.js

@@ -0,0 +1,419 @@
+import {
+  persisted,
+  stream
+} from "./chunk-QKYYD3AZ.js";
+import {
+  layer as layer2
+} from "./chunk-DHTPLWAP.js";
+import {
+  layer
+} from "./chunk-KEMBVIRS.js";
+import {
+  NodeHttpIncomingMessage
+} from "./chunk-AMAL6TRE.js";
+import {
+  NodeWS
+} from "./chunk-Q7YXUH7M.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeHttpServer.js
+var NodeHttpServer_exports = {};
+__export(NodeHttpServer_exports, {
+  layer: () => layer4,
+  layerConfig: () => layerConfig,
+  layerHttpServices: () => layerHttpServices,
+  layerServer: () => layerServer,
+  layerTest: () => layerTest,
+  make: () => make2,
+  makeHandler: () => makeHandler,
+  makeUpgradeHandler: () => makeUpgradeHandler
+});
+import * as Cause from "effect/Cause";
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import { flow } from "effect/Function";
+import * as Cookies from "effect/http/Cookies";
+import * as Etag from "effect/http/Etag";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as HttpEffect from "effect/http/HttpEffect";
+import * as HttpIncomingMessage from "effect/http/HttpIncomingMessage";
+import * as HttpServer from "effect/http/HttpServer";
+import { causeResponse, ClientAbort, HttpServerError, RequestParseError, ResponseError, ServeError } from "effect/http/HttpServerError";
+import * as Request from "effect/http/HttpServerRequest";
+import { HttpServerRequest } from "effect/http/HttpServerRequest";
+import * as Response from "effect/http/HttpServerResponse";
+import * as UrlParams from "effect/http/UrlParams";
+import * as Latch from "effect/Latch";
+import * as Layer from "effect/Layer";
+import * as NetAddress from "effect/net/NetAddress";
+import * as Scope from "effect/Scope";
+import * as Socket from "effect/socket/Socket";
+import * as Stream from "effect/Stream";
+import * as Http from "node:http";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+var make2 = /* @__PURE__ */ Effect.fnUntraced(function* (evaluate, options) {
+  const scope2 = yield* Effect.scope;
+  const server = evaluate();
+  const shutdown = yield* Effect.callback((resume) => {
+    if (!server.listening) {
+      return resume(Effect.void);
+    }
+    server.close((error) => {
+      if (error) {
+        resume(Effect.die(error));
+      } else {
+        resume(Effect.void);
+      }
+    });
+  }).pipe(Effect.cached);
+  const preemptiveShutdown = options.disablePreemptiveShutdown ? Effect.void : Effect.timeoutOrElse(shutdown, {
+    duration: options.gracefulShutdownTimeout ?? Duration.seconds(20),
+    orElse: () => Effect.void
+  });
+  yield* Scope.addFinalizer(scope2, shutdown);
+  yield* Effect.callback((resume) => {
+    function onError(cause) {
+      resume(Effect.fail(new ServeError({
+        cause
+      })));
+    }
+    server.on("error", onError);
+    server.listen(options, () => {
+      server.off("error", onError);
+      resume(Effect.void);
+    });
+  });
+  const address = server.address();
+  const effectAddress = typeof address === "string" ? Effect.succeed(NetAddress.unixPathAddress(address)) : Effect.fromResult(NetAddress.inetAddressFromIpString(address.address, address.port)).pipe(Effect.mapError((cause) => new ServeError({
+    cause
+  })));
+  const boundAddress = yield* effectAddress;
+  const wss = yield* Effect.acquireRelease(Effect.sync(() => new NodeWS.WebSocketServer({
+    ...options.websocket,
+    noServer: true
+  })), (wss2) => Effect.callback((resume) => {
+    wss2.close(() => resume(Effect.void));
+  })).pipe(Scope.provide(scope2), Effect.cached);
+  return HttpServer.make({
+    address: boundAddress,
+    serve: Effect.fnUntraced(function* (httpApp, middleware) {
+      const serveScope = yield* Effect.scope;
+      const scope3 = Scope.forkUnsafe(serveScope, "parallel");
+      const handler = yield* makeHandler(httpApp, {
+        middleware,
+        scope: scope3
+      });
+      const upgradeHandler = yield* makeUpgradeHandler(wss, httpApp, {
+        middleware,
+        scope: scope3
+      });
+      yield* Scope.addFinalizerExit(serveScope, () => Effect.ensuring(preemptiveShutdown, Effect.sync(() => {
+        server.off("request", handler);
+        server.off("upgrade", upgradeHandler);
+      })));
+      server.on("request", handler);
+      server.on("upgrade", upgradeHandler);
+    })
+  });
+});
+var makeHandler = (httpEffect, options) => {
+  const handled = HttpEffect.toHandled(httpEffect, handleResponse, options.middleware);
+  return Effect.withFiber((parent) => {
+    const services = parent.context;
+    return Effect.succeed(function handler(nodeRequest, nodeResponse) {
+      const context = Context.add(services, HttpServerRequest, new ServerRequestImpl(nodeRequest, nodeResponse));
+      const fiber = Fiber.runIn(Effect.runForkWith(context)(handled), options.scope);
+      if (fiber.pollUnsafe() === void 0) {
+        nodeResponse.on("close", () => {
+          if (!nodeResponse.writableEnded) {
+            fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+          }
+        });
+      }
+    });
+  });
+};
+var makeUpgradeHandler = (lazyWss, httpEffect, options) => {
+  const handledApp = HttpEffect.toHandled(httpEffect, handleResponse, options.middleware);
+  return Effect.withFiber((parent) => {
+    const services = parent.context;
+    return Effect.succeed(function handler(nodeRequest, socket, head) {
+      let nodeResponse_ = void 0;
+      const nodeResponse = () => {
+        if (nodeResponse_ === void 0) {
+          nodeResponse_ = new Http.ServerResponse(nodeRequest);
+          if (request.upgraded || socket.destroyed) {
+            nodeResponse_.end();
+          } else {
+            nodeResponse_.assignSocket(socket);
+            nodeResponse_.on("finish", () => {
+              socket.end();
+            });
+          }
+        }
+        return nodeResponse_;
+      };
+      const upgradeEffect = Socket.fromWebSocket(Effect.flatMap(lazyWss, (wss) => Effect.acquireRelease(Effect.callback((resume) => {
+        const onClose = () => resume(Effect.fail(new Socket.SocketError({
+          reason: new Socket.SocketOpenError({
+            kind: "Unknown",
+            cause: new Error("The socket closed before the upgrade")
+          })
+        })));
+        if (socket.destroyed) return onClose();
+        socket.once("close", onClose);
+        wss.handleUpgrade(nodeRequest, socket, head, (ws) => {
+          socket.off("close", onClose);
+          request.upgraded = true;
+          resume(Effect.succeed(ws));
+        });
+      }), (ws, exit) => Effect.sync(() => ws.close(closeCode(exit))))));
+      const request = new ServerRequestImpl(nodeRequest, nodeResponse, upgradeEffect);
+      const context = Context.add(services, HttpServerRequest, request);
+      const fiber = Fiber.runIn(Effect.runForkWith(context)(handledApp), options.scope);
+      socket.on("error", () => {
+      });
+      socket.on("close", () => {
+        if (!socket.writableEnded) {
+          fiber.interruptUnsafe(parent.id, ClientAbort.annotation);
+        }
+      });
+    });
+  });
+};
+var ServerRequestImpl = class _ServerRequestImpl extends NodeHttpIncomingMessage {
+  [Request.TypeId];
+  response;
+  upgradeEffect;
+  upgraded = false;
+  url;
+  headersOverride;
+  constructor(source, response, upgradeEffect, url = source.url, headersOverride, remoteAddressOverride) {
+    super(source, (cause) => new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        cause
+      })
+    }), remoteAddressOverride);
+    this[Request.TypeId] = Request.TypeId;
+    this.response = response;
+    this.upgradeEffect = upgradeEffect;
+    this.url = url;
+    this.headersOverride = headersOverride;
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies;
+    }
+    return this.cachedCookies = Cookies.parseHeader(this.headers.cookie ?? "");
+  }
+  get resolvedResponse() {
+    return typeof this.response === "function" ? this.response() : this.response;
+  }
+  modify(options) {
+    return new _ServerRequestImpl(this.source, this.response, this.upgradeEffect, options.url ?? this.url, options.headers ?? this.headersOverride, "remoteAddress" in options ? options.remoteAddress : this.remoteAddressOverride);
+  }
+  get originalUrl() {
+    return this.source.url;
+  }
+  cachedMethod;
+  get method() {
+    return this.cachedMethod ??= this.source.method.toUpperCase();
+  }
+  get headers() {
+    this.headersOverride ??= this.source.headers;
+    return this.headersOverride;
+  }
+  multipartEffect;
+  get multipart() {
+    if (this.multipartEffect) {
+      return this.multipartEffect;
+    }
+    this.multipartEffect = Effect.runSync(Effect.cached(persisted(this.source, this.source.headers)));
+    return this.multipartEffect;
+  }
+  get multipartStream() {
+    return stream(this.source, this.source.headers);
+  }
+  get upgrade() {
+    return this.upgradeEffect ?? Effect.fail(new HttpServerError({
+      reason: new RequestParseError({
+        request: this,
+        description: "not an upgradeable ServerRequest"
+      })
+    }));
+  }
+  toString() {
+    return `ServerRequest(${this.method} ${UrlParams.redactUrl(this.url)})`;
+  }
+  toJSON() {
+    return HttpIncomingMessage.inspect(this, {
+      _id: "HttpServerRequest",
+      method: this.method,
+      url: UrlParams.redactUrl(this.originalUrl)
+    });
+  }
+};
+var layerServer = /* @__PURE__ */ flow(make2, /* @__PURE__ */ Layer.effect(HttpServer.HttpServer));
+var layerHttpServices = /* @__PURE__ */ Layer.mergeAll(layer, Etag.layerWeak, layer2);
+var layer4 = (evaluate, options) => Layer.mergeAll(layerServer(evaluate, options), layerHttpServices);
+var layerConfig = (evaluate, options) => Layer.mergeAll(Layer.effect(HttpServer.HttpServer)(Effect.flatMap(Config.unwrap(options), (options2) => make2(evaluate, options2))), layerHttpServices);
+var layerTest = /* @__PURE__ */ HttpServer.layerTestClient.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.fresh(FetchHttpClient.layer).pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.succeed(FetchHttpClient.RequestInit)({
+  keepalive: false
+})))), /* @__PURE__ */ Layer.provideMerge(/* @__PURE__ */ layer4(Http.createServer, {
+  port: 0
+})));
+var closeCode = (exit) => Exit.isSuccess(exit) ? 1e3 : Cause.hasInterruptsOnly(exit.cause) ? 1001 : 1011;
+var upgradedResponse = /* @__PURE__ */ Response.empty({
+  status: 101
+});
+var handleResponse = (request, response) => {
+  if (request.upgraded) {
+    return Effect.succeed(upgradedResponse);
+  }
+  const nodeResponse = request.resolvedResponse;
+  if (nodeResponse.writableEnded) {
+    return Effect.void;
+  }
+  let headers = response.headers;
+  if (!Cookies.isEmpty(response.cookies)) {
+    headers = {
+      ...headers
+    };
+    const toSet = Cookies.toSetCookieHeaders(response.cookies);
+    if (headers["set-cookie"] !== void 0) {
+      toSet.push(headers["set-cookie"]);
+    }
+    headers["set-cookie"] = toSet;
+  }
+  if (request.method === "HEAD") {
+    nodeResponse.writeHead(response.status, response.statusText, headers);
+    return Effect.andThen(cancelResponseBody(response.body), Effect.callback((resume) => {
+      let completed = false;
+      const done = () => {
+        if (completed) return;
+        completed = true;
+        nodeResponse.off("close", done);
+        resume(Effect.void);
+      };
+      nodeResponse.once("close", done);
+      nodeResponse.end(done);
+    }));
+  }
+  const body = response.body;
+  switch (body._tag) {
+    case "Empty": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      nodeResponse.end();
+      return Effect.void;
+    }
+    case "Raw": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      if (typeof body.body === "object" && body.body !== null && "pipe" in body.body && typeof body.body.pipe === "function") {
+        return Effect.tryPromise({
+          try: (signal) => pipeline(body.body, nodeResponse, {
+            signal,
+            end: true
+          }),
+          catch: (cause) => new HttpServerError({
+            reason: new ResponseError({
+              request,
+              response,
+              description: "Error writing raw response",
+              cause
+            })
+          })
+        }).pipe(Effect.interruptible, Effect.tapCause(handleCause(nodeResponse, response)));
+      }
+      return Effect.callback((resume) => {
+        nodeResponse.end(body.body, () => resume(Effect.void));
+      });
+    }
+    case "Uint8Array": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      if (body.contentLength < 1024 * 1024) {
+        nodeResponse.end(body.text ?? body.body);
+        return Effect.void;
+      }
+      return Effect.callback((resume) => {
+        nodeResponse.end(body.text ?? body.body, () => resume(Effect.void));
+      });
+    }
+    case "FormData": {
+      return Effect.suspend(() => {
+        const r = new globalThis.Response(body.formData);
+        nodeResponse.writeHead(response.status, response.statusText, {
+          ...headers,
+          ...Object.fromEntries(r.headers)
+        });
+        return Effect.callback((resume, signal) => {
+          Readable.fromWeb(r.body, {
+            signal
+          }).pipe(nodeResponse).on("error", (cause) => {
+            resume(Effect.fail(new HttpServerError({
+              reason: new ResponseError({
+                request,
+                response,
+                description: "Error writing FormData response",
+                cause
+              })
+            })));
+          }).once("finish", () => {
+            resume(Effect.void);
+          });
+        }).pipe(Effect.interruptible, Effect.tapCause(handleCause(nodeResponse, response)));
+      });
+    }
+    case "Stream": {
+      nodeResponse.writeHead(response.status, response.statusText, headers);
+      const drainLatch = Latch.makeUnsafe();
+      nodeResponse.on("drain", () => drainLatch.openUnsafe());
+      return body.stream.pipe(Stream.orDie, Stream.runForEachArray((array) => {
+        const chunk = array.length > 1 ? Buffer.concat(array) : array[0];
+        if (nodeResponse.write(chunk)) return Effect.void;
+        drainLatch.closeUnsafe();
+        return drainLatch.await;
+      }), Effect.interruptible, Effect.matchCauseEffect({
+        onSuccess: () => Effect.sync(() => nodeResponse.end()),
+        onFailure: handleCause(nodeResponse, response)
+      }));
+    }
+  }
+};
+var cancelResponseBody = (body) => {
+  const stream2 = body._tag === "Raw" ? body.body : void 0;
+  if (stream2 instanceof Readable) {
+    return Effect.sync(() => stream2.destroy());
+  }
+  return Effect.void;
+};
+var handleCause = (nodeResponse, originalResponse) => (originalCause) => Effect.flatMap(causeResponse(originalCause), ([response, cause]) => {
+  const headersSent = nodeResponse.headersSent;
+  if (!headersSent) {
+    nodeResponse.writeHead(response.status, response.statusText);
+  }
+  if (!nodeResponse.writableEnded) {
+    nodeResponse.end();
+  }
+  return Effect.failCause(headersSent ? Cause.combine(originalCause, Cause.die(originalResponse)) : cause);
+});
+
+export {
+  make2 as make,
+  makeHandler,
+  makeUpgradeHandler,
+  layerServer,
+  layerHttpServices,
+  layer4 as layer,
+  layerConfig,
+  layerTest,
+  NodeHttpServer_exports
+};

package/dist/vendor/chunk-6R444NFO.js

@@ -0,0 +1,104 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeWorkerRunner.js
+var NodeWorkerRunner_exports = {};
+__export(NodeWorkerRunner_exports, {
+  layer: () => layer
+});
+import * as Cause from "effect/Cause";
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Fiber from "effect/Fiber";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/workers/WorkerError";
+import * as WorkerRunner from "effect/workers/WorkerRunner";
+import * as WorkerThreads from "node:worker_threads";
+var layer = /* @__PURE__ */ Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start() {
+    return Effect.gen(function* () {
+      if (!WorkerThreads.parentPort && !process.send) {
+        return yield* new WorkerError({
+          reason: new WorkerSpawnError({
+            message: "not in a worker"
+          })
+        });
+      }
+      const sendRaw = WorkerThreads.parentPort ? (_portId, message, transfers) => WorkerThreads.parentPort.postMessage(message, transfers) : (_portId, message, _transfers) => process.send(message);
+      const sendUnsafe = (_portId, message, transfers) => sendRaw(_portId, [1, message], transfers);
+      const send = (_portId, message, transfers) => Effect.sync(() => sendUnsafe(_portId, message, transfers));
+      const run = (handler) => Effect.scopedWith(Effect.fnUntraced(function* (scope) {
+        const closeLatch = Deferred.makeUnsafe();
+        const trackFiber = Fiber.runIn(scope);
+        const services = yield* Effect.context();
+        const runFork = Effect.runForkWith(services);
+        const onExit = (exit) => {
+          if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+            runFork(Effect.logError("unhandled error in worker", exit.cause));
+          }
+        };
+        const port = WorkerThreads.parentPort ?? process;
+        function onMessage(message) {
+          if (message[0] === 0) {
+            const result = handler(0, message[1]);
+            if (Effect.isEffect(result)) {
+              const fiber = runFork(result);
+              fiber.addObserver(onExit);
+              trackFiber(fiber);
+            }
+          } else {
+            if (WorkerThreads.parentPort) {
+              WorkerThreads.parentPort.close();
+            } else {
+              process.channel?.unref();
+            }
+            Deferred.doneUnsafe(closeLatch, Exit.void);
+          }
+        }
+        port.on("message", onMessage);
+        function onMessageError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received messageerror event",
+              cause
+            })
+          }));
+        }
+        function onError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received error event",
+              cause
+            })
+          }));
+        }
+        if (WorkerThreads.parentPort) {
+          WorkerThreads.parentPort.on("messageerror", onMessageError);
+          WorkerThreads.parentPort.on("error", onError);
+        }
+        yield* Scope.addFinalizer(scope, Effect.sync(() => {
+          port.off("message", onMessage);
+          if (WorkerThreads.parentPort) {
+            WorkerThreads.parentPort.off("messageerror", onMessageError);
+            WorkerThreads.parentPort.off("error", onError);
+          }
+        }));
+        sendRaw(0, [0]);
+        return yield* Deferred.await(closeLatch);
+      }));
+      return {
+        run,
+        send,
+        sendUnsafe
+      };
+    });
+  }
+});
+
+export {
+  layer,
+  NodeWorkerRunner_exports
+};