@smthrs/platform-node 0.0.0-stage → 1.0.0-rc.4

package/dist/vendor/chunk-DWSHTSVX.js

@@ -0,0 +1,229 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex
+} from "./chunk-JJ24ARBQ.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/NodeSocketServer.js
+var NodeSocketServer_exports = {};
+__export(NodeSocketServer_exports, {
+  IncomingMessage: () => IncomingMessage,
+  layer: () => layer,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  make: () => make2,
+  makeTls: () => makeTls,
+  makeWebSocket: () => makeWebSocket
+});
+import * as Context from "effect/Context";
+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 { pipe } from "effect/Function";
+import * as Function from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as References from "effect/References";
+import * as Scope from "effect/Scope";
+import * as NetAddress from "effect/unstable/net/NetAddress";
+import * as Socket from "effect/unstable/socket/Socket";
+import * as SocketServer from "effect/unstable/socket/SocketServer";
+import * as Net from "node:net";
+import * as Tls from "node:tls";
+var isDeno = "Deno" in globalThis;
+var socketAddressFromNode = (address) => typeof address === "string" ? Effect.succeed(NetAddress.unixPathAddress(address)) : Effect.fromResult(NetAddress.inetAddressFromIpString(address.address, address.port)).pipe(Effect.mapError((cause) => new SocketServer.SocketServerError({
+  reason: new SocketServer.SocketServerOpenError({
+    cause
+  })
+})));
+var IncomingMessage = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node-shared/NodeSocketServer/IncomingMessage")) {
+};
+var make2 = (options) => makeNetServer({
+  listenOptions: options,
+  connectionEvent: "connection",
+  createServer: () => Net.createServer(options)
+});
+var layer = /* @__PURE__ */ Function.flow(make2, /* @__PURE__ */ Layer.effect(SocketServer.SocketServer));
+var makeTls = (options) => makeNetServer({
+  listenOptions: options,
+  connectionEvent: "secureConnection",
+  createServer: () => {
+    const server = Tls.createServer(options);
+    server.on("tlsClientError", (_error, socket) => {
+      socket.destroy();
+    });
+    return server;
+  }
+});
+var layerTls = /* @__PURE__ */ Function.flow(makeTls, /* @__PURE__ */ Layer.effect(SocketServer.SocketServer));
+var makeWebSocket = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const pendingConnections = /* @__PURE__ */ new Map();
+  const server = yield* Effect.acquireRelease(Effect.sync(() => new NodeWS.WebSocketServer(options)), (server2) => Effect.callback((resume) => {
+    pendingConnections.forEach(([, remove], conn) => {
+      remove();
+      conn.terminate();
+    });
+    server2.close(() => resume(Effect.void));
+  }));
+  function defaultHandler(conn, req) {
+    const remove = () => {
+      pendingConnections.delete(conn);
+      conn.removeEventListener("close", remove);
+    };
+    pendingConnections.set(conn, [req, remove]);
+    conn.addEventListener("close", remove);
+  }
+  let onConnection = defaultHandler;
+  server.on("connection", (conn, req) => {
+    conn.pause();
+    onConnection(conn, req);
+  });
+  yield* Effect.callback((resume) => {
+    server.once("error", (error) => {
+      resume(Effect.fail(new SocketServer.SocketServerError({
+        reason: new SocketServer.SocketServerOpenError({
+          cause: error
+        })
+      })));
+    });
+    server.once("listening", () => {
+      resume(Effect.void);
+    });
+  });
+  const run = Effect.fnUntraced(function* (handler) {
+    const scope = yield* Scope.make();
+    const services = Context.omit(Scope.Scope)(yield* Effect.context());
+    const trackFiber = Fiber.runIn(scope);
+    const prevOnConnection = onConnection;
+    onConnection = function(conn, req) {
+      let context2 = services;
+      context2 = Context.add(context2, IncomingMessage, req);
+      context2 = Context.add(context2, Socket.WebSocket, conn);
+      pipe(Socket.fromWebSocket(Effect.acquireRelease(Effect.succeed(conn), (conn2) => Effect.sync(() => {
+        conn2.close();
+      }))), Effect.flatMap(handler), Effect.catchCause(reportUnhandledError), Effect.runForkWith(context2), trackFiber);
+    };
+    pendingConnections.forEach(([req, remove], conn) => {
+      remove();
+      onConnection(conn, req);
+    });
+    return yield* Effect.callback((_resume) => {
+      return Effect.sync(() => {
+        onConnection = prevOnConnection;
+      });
+    }).pipe(Effect.ensuring(Scope.close(scope, Exit.void)));
+  });
+  const boundAddress = yield* socketAddressFromNode(server.address());
+  return SocketServer.SocketServer.of({
+    address: boundAddress,
+    run
+  });
+});
+var layerWebSocket = /* @__PURE__ */ Function.flow(makeWebSocket, /* @__PURE__ */ Layer.effect(SocketServer.SocketServer));
+var reportUnhandledError = (cause) => Effect.withFiber((fiber) => {
+  const unhandledLogLevel = fiber.getRef(References.UnhandledLogLevel);
+  if (unhandledLogLevel) {
+    return Effect.logWithLevel(unhandledLogLevel)(cause, "Unhandled error in SocketServer");
+  }
+  return Effect.void;
+});
+var makeNetServer = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const errorDeferred = Deferred.makeUnsafe();
+  const pending = /* @__PURE__ */ new Map();
+  function defaultOnConnection(conn) {
+    const remove = () => {
+      pending.delete(conn);
+      conn.off("close", remove);
+      conn.off("error", remove);
+    };
+    pending.set(conn, remove);
+    conn.on("close", remove);
+    conn.on("error", remove);
+  }
+  let onConnection = defaultOnConnection;
+  let server;
+  yield* Effect.addFinalizer(() => Effect.callback((resume) => {
+    pending.forEach((remove, conn) => {
+      remove();
+      conn.destroy();
+    });
+    server?.close(() => resume(Effect.void));
+  }));
+  server = options.createServer();
+  server.on(options.connectionEvent, (conn) => {
+    if (!isDeno) conn.pause();
+    onConnection(conn);
+  });
+  server.on("error", (err) => Deferred.doneUnsafe(errorDeferred, Exit.fail(err)));
+  yield* Effect.callback((resume) => {
+    server.listen(options.listenOptions, () => resume(Effect.void));
+  }).pipe(Effect.raceFirst(Effect.mapError(Deferred.await(errorDeferred), (err) => new SocketServer.SocketServerError({
+    reason: new SocketServer.SocketServerOpenError({
+      cause: err
+    })
+  }))));
+  const run = Effect.fnUntraced(function* (handler) {
+    const scope = yield* Scope.make();
+    const services = Context.omit(Scope.Scope)(yield* Effect.context());
+    const trackFiber = Fiber.runIn(scope);
+    const prevOnConnection = onConnection;
+    onConnection = function(conn) {
+      let error;
+      conn.on("error", (err) => {
+        error = err;
+      });
+      pipe(fromDuplex(Effect.acquireRelease(Effect.suspend(() => {
+        if (error) {
+          return Effect.fail(new Socket.SocketError({
+            reason: new Socket.SocketOpenError({
+              kind: "Unknown",
+              cause: error
+            })
+          }));
+        } else if (conn.closed) {
+          return Effect.fail(new Socket.SocketError({
+            reason: new Socket.SocketCloseError({
+              code: 1e3
+            })
+          }));
+        }
+        return Effect.succeed(conn);
+      }), (conn2) => Effect.sync(() => {
+        if (conn2.closed === false) {
+          conn2.destroySoon();
+        }
+      })), {
+        tlsServer: true
+      }), Effect.flatMap(handler), Effect.catchCause(reportUnhandledError), Effect.runForkWith(Context.add(services, NetSocket, conn)), trackFiber);
+    };
+    pending.forEach((remove, conn) => {
+      remove();
+      onConnection(conn);
+    });
+    return yield* Effect.callback((_resume) => {
+      return Effect.suspend(() => {
+        onConnection = prevOnConnection;
+        return Scope.close(scope, Exit.void);
+      });
+    });
+  });
+  const boundAddress = yield* socketAddressFromNode(server.address());
+  return SocketServer.SocketServer.of({
+    address: boundAddress,
+    run
+  });
+});
+
+export {
+  IncomingMessage,
+  make2 as make,
+  layer,
+  makeTls,
+  layerTls,
+  makeWebSocket,
+  layerWebSocket,
+  NodeSocketServer_exports
+};

package/dist/vendor/chunk-EGBNVEEW.js

@@ -0,0 +1,14 @@
+// ../../../../node_modules/.pnpm/@effect+platform-node-shared@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-node-shared/dist/internal/nodeChildProcessSpawner.js
+var buildSpawnOptions = (options, base, platform) => {
+  const detached = options.detached ?? platform !== "win32";
+  return {
+    ...base,
+    detached,
+    shell: options.shell,
+    windowsHide: options.windowsHide ?? !detached
+  };
+};
+
+export {
+  buildSpawnOptions
+};

package/dist/vendor/chunk-EZWY45HP.js

@@ -0,0 +1,18 @@
+import {
+  runMain
+} from "./chunk-LEUPYT3Q.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeRuntime.js
+var NodeRuntime_exports = {};
+__export(NodeRuntime_exports, {
+  runMain: () => runMain2
+});
+var runMain2 = runMain;
+
+export {
+  runMain2 as runMain,
+  NodeRuntime_exports
+};

package/dist/vendor/chunk-FNZOJHSV.js

@@ -0,0 +1,71 @@
+import {
+  layerClientProtocol,
+  layerSocketServer
+} from "./chunk-Y35ZAO5U.js";
+import {
+  layer
+} from "./chunk-VZBDV3TV.js";
+import {
+  Dispatcher,
+  layerUndiciNoDispatcher,
+  makeDispatcher
+} from "./chunk-KOZMM5PZ.js";
+import {
+  layer as layer2
+} from "./chunk-M32LDTW7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeClusterSocket.js
+var NodeClusterSocket_exports = {};
+__export(NodeClusterSocket_exports, {
+  layer: () => layer7,
+  layerClientProtocol: () => layerClientProtocol,
+  layerDispatcherK8s: () => layerDispatcherK8s,
+  layerK8sHttpClient: () => layerK8sHttpClient,
+  layerSocketServer: () => layerSocketServer
+});
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as K8sHttpClient from "effect/unstable/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as RunnerHealth from "effect/unstable/cluster/RunnerHealth";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as SocketRunner from "effect/unstable/cluster/SocketRunner";
+import * as SqlMessageStorage from "effect/unstable/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/unstable/cluster/SqlRunnerStorage";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+var layer7 = (options) => {
+  const layer8 = options?.clientOnly ? Layer.provide(SocketRunner.layerClientOnly, layerClientProtocol) : Layer.provide(SocketRunner.layer, [layerSocketServer, layerClientProtocol]);
+  const runnerHealth = options?.clientOnly ? Layer.empty : options?.runnerHealth === "k8s" ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(Layer.provide(layerK8sHttpClient)) : RunnerHealth.layerPing.pipe(Layer.provide(Runners.layerRpc), Layer.provide(layerClientProtocol));
+  return layer8.pipe(Layer.provide(runnerHealth), Layer.provideMerge(options?.storage === "local" ? MessageStorage.layerNoop : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlMessageStorage.layer).pipe(Layer.provide(layer))), Layer.provide(options?.storage === "local" ? RunnerStorage.layerMemory : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlRunnerStorage.layer)), Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)), Layer.provide(options?.serialization === "ndjson" ? RpcSerialization.layerNdjsonWith({
+    maxBufferSize: options?.serializationMaxBufferSize
+  }) : RpcSerialization.layerSchemaBinary({
+    maxFrameSize: options?.serializationMaxBufferSize
+  })));
+};
+var layerDispatcherK8s = /* @__PURE__ */ Layer.effect(Dispatcher)(Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const caCertOption = yield* fs.readFileString("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(Effect.option);
+  if (caCertOption._tag === "Some") {
+    const Undici = yield* Effect.promise(() => import("./node/Undici.js"));
+    return yield* Effect.acquireRelease(Effect.sync(() => new Undici.Agent({
+      connect: {
+        ca: caCertOption.value
+      }
+    })), (agent) => Effect.promise(() => agent.destroy()));
+  }
+  return yield* makeDispatcher;
+})).pipe(/* @__PURE__ */ Layer.provide(layer2));
+var layerK8sHttpClient = /* @__PURE__ */ K8sHttpClient.layer.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.fresh(layerUndiciNoDispatcher)), /* @__PURE__ */ Layer.provide(layerDispatcherK8s), /* @__PURE__ */ Layer.provide(layer2));
+
+export {
+  layer7 as layer,
+  layerDispatcherK8s,
+  layerK8sHttpClient,
+  NodeClusterSocket_exports
+};

package/dist/vendor/chunk-GXCHI7BM.js

@@ -0,0 +1,131 @@
+import {
+  make
+} from "./chunk-2Y7WC4KU.js";
+import {
+  fromReadable,
+  toUint8Array
+} from "./chunk-XH4U3JSV.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeMultipart.js
+var NodeMultipart_exports = {};
+__export(NodeMultipart_exports, {
+  fileToReadable: () => fileToReadable,
+  persisted: () => persisted,
+  stream: () => stream
+});
+import * as Effect from "effect/Effect";
+import * as Inspectable from "effect/Inspectable";
+import * as Stream from "effect/Stream";
+import * as Multipart from "effect/unstable/http/Multipart";
+import * as MultipartParser from "effect/unstable/http/MultipartParser";
+import * as NFS from "node:fs";
+import * as NodeStreamP from "node:stream/promises";
+var stream = (source, headers) => Multipart.makeConfig(headers).pipe(Effect.map((config) => fromReadable({
+  evaluate() {
+    const parser = make(config);
+    source.pipe(parser);
+    return parser;
+  },
+  onError: (error) => convertError(error)
+})), Stream.unwrap, Stream.map(convertPart));
+var persisted = (source, headers) => Multipart.toPersisted(stream(source, headers), (path, file) => Effect.tryPromise({
+  try: (signal) => NodeStreamP.pipeline(file.file, NFS.createWriteStream(path), {
+    signal
+  }),
+  catch: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+}));
+var fileToReadable = (file) => file.file;
+var convertPart = (part) => part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part);
+var PartBase = class extends Inspectable.Class {
+  [Multipart.TypeId];
+  constructor() {
+    super();
+    this[Multipart.TypeId] = Multipart.TypeId;
+  }
+};
+var FieldImpl = class extends PartBase {
+  _tag = "Field";
+  key;
+  contentType;
+  value;
+  constructor(info, value) {
+    super();
+    this.key = info.name;
+    this.contentType = info.contentType;
+    this.value = MultipartParser.decodeField(info, value);
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "Field",
+      key: this.key,
+      value: this.value,
+      contentType: this.contentType
+    };
+  }
+};
+var FileImpl = class extends PartBase {
+  _tag = "File";
+  key;
+  name;
+  contentType;
+  content;
+  contentEffect;
+  file;
+  constructor(file) {
+    super();
+    this.file = file;
+    this.key = file.info.name;
+    this.name = file.filename ?? file.info.name;
+    this.contentType = file.info.contentType;
+    this.content = fromReadable({
+      evaluate: () => file,
+      onError: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+    });
+    this.contentEffect = toUint8Array(() => file, {
+      onError: (cause) => Multipart.MultipartError.fromReason("InternalError", cause)
+    });
+  }
+  toJSON() {
+    return {
+      _id: "@effect/platform/Multipart/Part",
+      _tag: "File",
+      key: this.key,
+      name: this.name,
+      contentType: this.contentType
+    };
+  }
+};
+function convertError(cause) {
+  switch (cause._tag) {
+    case "ReachedLimit": {
+      switch (cause.limit) {
+        case "MaxParts": {
+          return Multipart.MultipartError.fromReason("TooManyParts", cause);
+        }
+        case "MaxFieldSize": {
+          return Multipart.MultipartError.fromReason("FieldTooLarge", cause);
+        }
+        case "MaxPartSize": {
+          return Multipart.MultipartError.fromReason("FileTooLarge", cause);
+        }
+        case "MaxTotalSize": {
+          return Multipart.MultipartError.fromReason("BodyTooLarge", cause);
+        }
+      }
+    }
+    default: {
+      return Multipart.MultipartError.fromReason("Parse", cause);
+    }
+  }
+}
+
+export {
+  stream,
+  persisted,
+  fileToReadable,
+  NodeMultipart_exports
+};

package/dist/vendor/chunk-IIJ52ZU6.js

@@ -0,0 +1,20 @@
+import {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable
+} from "./chunk-OXNGN5H7.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeSink.js
+var NodeSink_exports = {};
+__export(NodeSink_exports, {
+  fromWritable: () => fromWritable,
+  fromWritableChannel: () => fromWritableChannel,
+  pullIntoWritable: () => pullIntoWritable
+});
+
+export {
+  NodeSink_exports
+};

package/dist/vendor/chunk-J7A4CZDO.js

@@ -0,0 +1,92 @@
+import {
+  fromReadable,
+  toArrayBuffer
+} from "./chunk-XH4U3JSV.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeHttpIncomingMessage.js
+var NodeHttpIncomingMessage_exports = {};
+__export(NodeHttpIncomingMessage_exports, {
+  NodeHttpIncomingMessage: () => NodeHttpIncomingMessage
+});
+import * as Effect from "effect/Effect";
+import * as Inspectable from "effect/Inspectable";
+import * as Option from "effect/Option";
+import * as Headers from "effect/unstable/http/Headers";
+import * as IncomingMessage from "effect/unstable/http/HttpIncomingMessage";
+import * as UrlParams from "effect/unstable/http/UrlParams";
+var NodeHttpIncomingMessage = class extends Inspectable.Class {
+  /**
+   * Marks this value as an HTTP incoming message for runtime guards.
+   *
+   * @since 4.0.0
+   */
+  [IncomingMessage.TypeId];
+  source;
+  onError;
+  remoteAddressOverride;
+  constructor(source, onError, remoteAddressOverride) {
+    super();
+    this[IncomingMessage.TypeId] = IncomingMessage.TypeId;
+    this.source = source;
+    this.onError = onError;
+    this.remoteAddressOverride = remoteAddressOverride;
+  }
+  get headers() {
+    return Headers.fromInput(this.source.headers);
+  }
+  get remoteAddress() {
+    return this.remoteAddressOverride ?? Option.fromNullishOr(this.source.socket?.remoteAddress);
+  }
+  textEffect;
+  get text() {
+    if (this.textEffect) {
+      return this.textEffect;
+    }
+    this.textEffect = Effect.map(this.arrayBuffer, (_) => Buffer.from(_).toString("utf8"));
+    return this.textEffect;
+  }
+  get textUnsafe() {
+    return Effect.runSync(this.text);
+  }
+  get json() {
+    return Effect.flatMap(this.text, (text) => Effect.try({
+      try: () => text === "" ? null : JSON.parse(text),
+      catch: this.onError
+    }));
+  }
+  get jsonUnsafe() {
+    return Effect.runSync(this.json);
+  }
+  get urlParamsBody() {
+    return Effect.flatMap(this.text, (_) => Effect.try({
+      try: () => UrlParams.fromInput(new URLSearchParams(_)),
+      catch: this.onError
+    }));
+  }
+  get stream() {
+    return fromReadable({
+      evaluate: () => this.source,
+      onError: this.onError
+    });
+  }
+  arrayBufferEffect;
+  get arrayBuffer() {
+    if (this.arrayBufferEffect) {
+      return this.arrayBufferEffect;
+    }
+    this.arrayBufferEffect = Effect.withFiber((fiber) => toArrayBuffer(() => this.source, {
+      onError: this.onError,
+      maxBytes: fiber.getRef(IncomingMessage.MaxBodySize)
+    })).pipe(Effect.cached, Effect.runSync);
+    this.textEffect = Effect.map(this.arrayBufferEffect, (_) => new TextDecoder().decode(_));
+    return this.arrayBufferEffect;
+  }
+};
+
+export {
+  NodeHttpIncomingMessage,
+  NodeHttpIncomingMessage_exports
+};

package/dist/vendor/chunk-JG5TTWPT.js

@@ -0,0 +1,85 @@
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.0-rc.115_effect@4.0.0-rc.115_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeWorker.js
+var NodeWorker_exports = {};
+__export(NodeWorker_exports, {
+  layer: () => layer,
+  layerPlatform: () => layerPlatform
+});
+import * as Deferred from "effect/Deferred";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import * as Worker from "effect/unstable/workers/Worker";
+import { WorkerError, WorkerReceiveError } from "effect/unstable/workers/WorkerError";
+var layerPlatform = /* @__PURE__ */ Layer.succeed(Worker.WorkerPlatform)(/* @__PURE__ */ Worker.makePlatform()({
+  setup({
+    scope,
+    worker
+  }) {
+    const exitDeferred = Deferred.makeUnsafe();
+    const thing = "postMessage" in worker ? {
+      postMessage(msg, t) {
+        worker.postMessage(msg, t);
+      },
+      kill: () => worker.terminate(),
+      worker
+    } : {
+      postMessage(msg, _) {
+        worker.send(msg);
+      },
+      kill: () => worker.kill("SIGKILL"),
+      worker
+    };
+    worker.on("exit", () => {
+      Deferred.doneUnsafe(exitDeferred, Exit.void);
+    });
+    return Effect.as(Scope.addFinalizer(scope, Effect.suspend(() => {
+      thing.postMessage([1]);
+      return Deferred.await(exitDeferred);
+    }).pipe(Effect.timeout(5e3), Effect.catchCause(() => Effect.promise(() => Promise.resolve(thing.kill()))))), thing);
+  },
+  listen({
+    deferred,
+    emit,
+    port
+  }) {
+    port.worker.on("message", (message) => {
+      emit(message);
+    });
+    port.worker.on("messageerror", (cause) => {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerReceiveError({
+          message: "An messageerror event was emitted",
+          cause
+        })
+      }));
+    });
+    port.worker.on("error", (cause) => {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerReceiveError({
+          message: "An error event was emitted",
+          cause
+        })
+      }));
+    });
+    port.worker.on("exit", (code) => {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerReceiveError({
+          message: "The worker has exited with code: " + code
+        })
+      }));
+    });
+    return Effect.void;
+  }
+}));
+var layer = (spawn) => Layer.merge(Worker.layerSpawner(spawn), layerPlatform);
+
+export {
+  layerPlatform,
+  layer,
+  NodeWorker_exports
+};