@smthrs/gateway 0.34.0 → 1.0.0-rc.3

package/dist/vendor/chunk-2GCOZTTW.js

@@ -0,0 +1,48 @@
+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/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-37CUR3PO.js

@@ -0,0 +1,81 @@
+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/NodeSink.js
+var NodeSink_exports = {};
+__export(NodeSink_exports, {
+  fromWritable: () => fromWritable,
+  fromWritableChannel: () => fromWritableChannel,
+  pullIntoWritable: () => pullIntoWritable
+});
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Sink from "effect/Sink";
+var fromWritable = (options) => Sink.fromChannel(Channel.mapDone(fromWritableChannel(options), (_) => [_]));
+var fromWritableChannel = (options) => Channel.fromTransform((pull) => {
+  const writable = options.evaluate();
+  return Effect.succeed(pullIntoWritable({
+    ...options,
+    writable,
+    pull
+  }));
+});
+var pullIntoWritable = (options) => options.pull.pipe(Effect.flatMap((chunk) => {
+  let i = 0;
+  return Effect.callback((resume) => {
+    let cancelled = false;
+    const loop = () => {
+      for (; i < chunk.length; ) {
+        if (cancelled) {
+          return;
+        }
+        const success = options.writable.write(chunk[i++], options.encoding);
+        if (!success) {
+          if (!cancelled) {
+            options.writable.once("drain", loop);
+          }
+          return;
+        }
+      }
+      if (!cancelled) {
+        resume(Effect.void);
+      }
+    };
+    loop();
+    return Effect.sync(() => {
+      cancelled = true;
+      options.writable.off("drain", loop);
+    });
+  });
+}), Effect.forever({
+  disableYield: true
+}), options.endOnDone !== false ? Pull.catchDone((_) => {
+  if ("closed" in options.writable && options.writable.closed) {
+    return Cause.done(_);
+  }
+  return Effect.callback((resume) => {
+    const onFinish = () => resume(Cause.done(_));
+    options.writable.once("finish", onFinish);
+    options.writable.end();
+    return Effect.sync(() => {
+      options.writable.off("finish", onFinish);
+    });
+  });
+}) : identity, Effect.raceFirst(Effect.callback((resume) => {
+  const onError = (error) => resume(Effect.fail(options.onError(error)));
+  options.writable.once("error", onError);
+  return Effect.sync(() => {
+    options.writable.off("error", onError);
+  });
+})));
+
+export {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable,
+  NodeSink_exports
+};

package/dist/vendor/chunk-3ARKKENZ.js

@@ -0,0 +1,45 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+} from "./chunk-YDASSC75.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunSocket.js
+var BunSocket_exports = {};
+__export(BunSocket_exports, {
+  NetSocket: () => NetSocket,
+  NodeWS: () => NodeWS,
+  fromDuplex: () => fromDuplex,
+  layerNet: () => layerNet,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  layerWebSocketConstructor: () => layerWebSocketConstructor,
+  makeNet: () => makeNet,
+  makeNetChannel: () => makeNetChannel,
+  makeTls: () => makeTls,
+  makeTlsChannel: () => makeTlsChannel
+});
+import { flow } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/unstable/socket/Socket";
+var layerWebSocketConstructor = /* @__PURE__ */ Layer.succeed(Socket.WebSocketConstructor)((url, options) => (
+  // Bun accepts `WebSocketOptions`, but `bun-types` selects the DOM overload
+  // when `lib.dom` is loaded and hides those constructor options.
+  new globalThis.WebSocket(url, options)
+));
+var layerWebSocket = /* @__PURE__ */ flow(Socket.makeWebSocket, /* @__PURE__ */ Layer.effect(Socket.Socket), /* @__PURE__ */ Layer.provide(layerWebSocketConstructor));
+
+export {
+  layerWebSocketConstructor,
+  layerWebSocket,
+  BunSocket_exports
+};

package/dist/vendor/chunk-3NV2UDBI.js

@@ -0,0 +1,7 @@
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunHttpClient.js
+var BunHttpClient_exports = {};
+export * from "effect/unstable/http/FetchHttpClient";
+
+export {
+  BunHttpClient_exports
+};

package/dist/vendor/chunk-3OSW7CT7.js

@@ -0,0 +1,143 @@
+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/NodeTerminal.js
+var NodeTerminal_exports = {};
+__export(NodeTerminal_exports, {
+  layer: () => layer,
+  make: () => make4
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { badArgument } from "effect/PlatformError";
+import * as Predicate from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import * as RcRef from "effect/RcRef";
+import * as Terminal from "effect/Terminal";
+import * as readline from "node:readline";
+var make4 = /* @__PURE__ */ Effect.fnUntraced(function* (shouldQuit = defaultShouldQuit) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const lines = yield* Queue.make();
+  let inputEnded = stdin.readableEnded;
+  let readlineActive = false;
+  const onStdinEnd = () => {
+    inputEnded = true;
+    if (!readlineActive) {
+      Queue.endUnsafe(lines);
+    }
+  };
+  stdin.once("end", onStdinEnd);
+  yield* Effect.addFinalizer(() => Effect.sync(() => stdin.off("end", onStdinEnd)));
+  const rlRef = yield* RcRef.make({
+    acquire: Effect.acquireRelease(Effect.sync(() => {
+      const rl = readline.createInterface({
+        input: stdin,
+        escapeCodeTimeout: 50
+      });
+      const onLine = (line) => Queue.offerUnsafe(lines, line);
+      const onClose = () => {
+        readlineActive = false;
+        Queue.endUnsafe(lines);
+      };
+      readlineActive = true;
+      readline.emitKeypressEvents(stdin, rl);
+      rl.on("line", onLine);
+      rl.once("close", onClose);
+      if (stdin.isTTY) {
+        stdin.setRawMode(true);
+      }
+      return {
+        rl,
+        onClose,
+        onLine
+      };
+    }), ({
+      rl,
+      onClose,
+      onLine
+    }) => Effect.sync(() => {
+      readlineActive = false;
+      rl.off("line", onLine);
+      rl.off("close", onClose);
+      if (stdin.isTTY) {
+        stdin.setRawMode(false);
+      }
+      rl.close();
+      if (inputEnded) {
+        Queue.endUnsafe(lines);
+      }
+    })),
+    idleTimeToLive: "10 millis"
+  });
+  const columns = Effect.sync(() => stdout.columns ?? 0);
+  const rows = Effect.sync(() => stdout.rows ?? 0);
+  const readInput = Effect.gen(function* () {
+    const queue = yield* Queue.make();
+    const handleKeypress = (s, k) => {
+      const userInput = {
+        input: Option.fromUndefinedOr(s),
+        key: {
+          name: k.name ?? "",
+          ctrl: !!k.ctrl,
+          meta: !!k.meta,
+          shift: !!k.shift
+        }
+      };
+      Queue.offerUnsafe(queue, userInput);
+      if (shouldQuit(userInput)) {
+        Queue.endUnsafe(queue);
+      }
+    };
+    const keepAlive = setInterval(() => {
+    }, 2147483647);
+    const handleEnd = () => {
+      clearInterval(keepAlive);
+      Queue.endUnsafe(queue);
+    };
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+      clearInterval(keepAlive);
+      stdin.off("keypress", handleKeypress);
+      stdin.off("end", handleEnd);
+    }));
+    stdin.on("keypress", handleKeypress);
+    if (inputEnded) {
+      handleEnd();
+    } else {
+      yield* RcRef.get(rlRef);
+      stdin.once("end", handleEnd);
+    }
+    return queue;
+  });
+  const readLine = Effect.suspend(() => Queue.poll(lines).pipe(Effect.flatMap(Option.match({
+    onNone: () => Effect.scoped(Effect.andThen(RcRef.get(rlRef), Queue.take(lines))),
+    onSome: Effect.succeed
+  })), Effect.mapError(() => new Terminal.QuitError({}))));
+  const display = (prompt) => Effect.uninterruptible(Effect.callback((resume) => {
+    stdout.write(prompt, (err) => Predicate.isNullish(err) ? resume(Effect.void) : resume(Effect.fail(badArgument({
+      module: "Terminal",
+      method: "display",
+      description: "Failed to write prompt to stdout",
+      cause: err
+    }))));
+  }));
+  return Terminal.make({
+    columns,
+    rows,
+    readInput,
+    readLine,
+    display
+  });
+});
+var layer = /* @__PURE__ */ Layer.effect(Terminal.Terminal, /* @__PURE__ */ make4(defaultShouldQuit));
+function defaultShouldQuit(input) {
+  return input.key.ctrl && (input.key.name === "c" || input.key.name === "d");
+}
+
+export {
+  make4 as make,
+  layer,
+  NodeTerminal_exports
+};

package/dist/vendor/chunk-62R63L74.js

@@ -0,0 +1,62 @@
+import {
+  layer as layer2
+} from "./chunk-TGXCX6W3.js";
+import {
+  layerWebSocketConstructor
+} from "./chunk-FPQF7CR5.js";
+import {
+  layerK8sHttpClient
+} from "./chunk-MSCLEMYX.js";
+import {
+  layer
+} from "./chunk-DS2R6WOM.js";
+import {
+  layerUndici
+} from "./chunk-WECQDT36.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/NodeClusterHttp.js
+var NodeClusterHttp_exports = {};
+__export(NodeClusterHttp_exports, {
+  layer: () => layer5,
+  layerHttpServer: () => layerHttpServer,
+  layerK8sHttpClient: () => layerK8sHttpClient
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as HttpRunner from "effect/unstable/cluster/HttpRunner";
+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 SqlMessageStorage from "effect/unstable/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/unstable/cluster/SqlRunnerStorage";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { createServer } from "node:http";
+var layer5 = (options) => {
+  const layer6 = options.clientOnly ? options.transport === "http" ? Layer.provide(HttpRunner.layerHttpClientOnly, layerUndici) : Layer.provide(HttpRunner.layerWebsocketClientOnly, layerWebSocketConstructor) : options.transport === "http" ? Layer.provide(HttpRunner.layerHttp, [layerHttpServer, layerUndici]) : Layer.provide(HttpRunner.layerWebsocket, [layerHttpServer, layerWebSocketConstructor]);
+  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(options.transport === "http" ? HttpRunner.layerClientProtocolHttpDefault.pipe(Layer.provide(layerUndici)) : HttpRunner.layerClientProtocolWebsocketDefault.pipe(Layer.provide(layerWebSocketConstructor))));
+  return layer6.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 layerHttpServer = /* @__PURE__ */ Effect.gen(function* () {
+  const config = yield* ShardingConfig.ShardingConfig;
+  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress);
+  if (Option.isNone(listenAddress)) {
+    return yield* Effect.die("NodeClusterHttp.layerHttpServer: ShardingConfig.runnerAddress is None");
+  }
+  return layer2(createServer, listenAddress.value);
+}).pipe(Layer.unwrap);
+
+export {
+  layer5 as layer,
+  layerHttpServer,
+  NodeClusterHttp_exports
+};

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

@@ -0,0 +1,118 @@
+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/NodeHttpCompression.js
+var NodeHttpCompression_exports = {};
+__export(NodeHttpCompression_exports, {
+  algorithms: () => algorithms,
+  compressTransform: () => compressTransform,
+  compressTransformWeb: () => compressTransformWeb,
+  make: () => make
+});
+import * as Effect from "effect/Effect";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as Response from "effect/unstable/http/HttpServerResponse";
+import { Readable } from "node:stream";
+import * as Zlib from "node:zlib";
+var algorithms = /* @__PURE__ */ new Set(typeof Zlib.zstdCompress === "function" ? ["gzip", "deflate", "br", "zstd"] : ["gzip", "deflate", "br"]);
+var brotliParams = (level, sizeHint) => {
+  const params = {};
+  if (level !== void 0) {
+    params[Zlib.constants.BROTLI_PARAM_QUALITY] = level;
+  }
+  if (sizeHint !== void 0) {
+    params[Zlib.constants.BROTLI_PARAM_SIZE_HINT] = sizeHint;
+  }
+  return {
+    params
+  };
+};
+var zstdParams = (level) => level === void 0 || level === 3 ? void 0 : {
+  params: {
+    [Zlib.constants.ZSTD_c_compressionLevel]: level
+  }
+};
+var compress = (data, algorithm, options) => Effect.callback((resume) => {
+  const complete = (error, result) => resume(error === null ? Effect.succeed(result) : Effect.die(error));
+  switch (algorithm) {
+    case "gzip": {
+      Zlib.gzip(data, {
+        level: options?.level
+      }, complete);
+      break;
+    }
+    case "deflate": {
+      Zlib.deflate(data, {
+        level: options?.level
+      }, complete);
+      break;
+    }
+    case "br": {
+      Zlib.brotliCompress(data, brotliParams(options?.level, data.byteLength), complete);
+      break;
+    }
+    case "zstd": {
+      const params = zstdParams(options?.level);
+      if (params === void 0) {
+        Zlib.zstdCompress(data, complete);
+      } else {
+        Zlib.zstdCompress(data, params, complete);
+      }
+      break;
+    }
+  }
+});
+var make = (fallback) => ({
+  algorithms: fallback.algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body;
+    if (body._tag !== "Uint8Array") {
+      return fallback.compressResponse(response, algorithm, options);
+    }
+    return Effect.map(compress(body.body, algorithm, options), (result) => Response.setHeader(Response.setBody(response, HttpBody.uint8Array(result, response.headers["content-type"] ?? body.contentType)), "content-length", result.byteLength.toString()));
+  }
+});
+var compressTransform = (algorithm, options) => {
+  switch (algorithm) {
+    case "gzip": {
+      return Zlib.createGzip({
+        level: options?.level,
+        flush: Zlib.constants.Z_SYNC_FLUSH
+      });
+    }
+    case "deflate": {
+      return Zlib.createDeflate({
+        level: options?.level,
+        flush: Zlib.constants.Z_SYNC_FLUSH
+      });
+    }
+    case "br": {
+      return Zlib.createBrotliCompress({
+        ...brotliParams(options?.level),
+        flush: Zlib.constants.BROTLI_OPERATION_FLUSH
+      });
+    }
+    case "zstd": {
+      return Zlib.createZstdCompress({
+        ...zstdParams(options?.level),
+        flush: Zlib.constants.ZSTD_e_flush
+      });
+    }
+  }
+};
+var compressTransformWeb = (algorithm, options) => (stream) => {
+  const transform = compressTransform(algorithm, options);
+  const source = Readable.fromWeb(stream);
+  source.on("error", (cause) => transform.destroy(cause));
+  transform.on("close", () => source.destroy());
+  return Readable.toWeb(source.pipe(transform));
+};
+
+export {
+  algorithms,
+  make,
+  compressTransform,
+  compressTransformWeb,
+  NodeHttpCompression_exports
+};

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

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-2GCOZTTW.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunCrypto.js
+var BunCrypto_exports = {};
+__export(BunCrypto_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  BunCrypto_exports
+};

package/dist/vendor/chunk-6DY5RBZD.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
+};

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

@@ -0,0 +1,53 @@
+import {
+  layer
+} from "./chunk-Z7QNPJEB.js";
+import {
+  makeNet
+} from "./chunk-YDASSC75.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/NodeClusterSocket.js
+var NodeClusterSocket_exports = {};
+__export(NodeClusterSocket_exports, {
+  layerClientProtocol: () => layerClientProtocol,
+  layerSocketServer: () => layerSocketServer
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as RpcClient from "effect/unstable/rpc/RpcClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import { Socket } from "effect/unstable/socket/Socket";
+var layerClientProtocol = /* @__PURE__ */ Layer.effect(Runners.RpcClientProtocol)(/* @__PURE__ */ Effect.gen(function* () {
+  const serialization = yield* RpcSerialization.RpcSerialization;
+  return {
+    codecFor: serialization.codecFor,
+    make: Effect.fnUntraced(function* (address) {
+      const socket = yield* makeNet({
+        openTimeout: 1e3,
+        timeout: 5500,
+        host: address.host,
+        port: address.port
+      });
+      return yield* RpcClient.makeProtocolSocket().pipe(Effect.provideService(Socket, socket), Effect.provideService(RpcSerialization.RpcSerialization, serialization));
+    }, Effect.orDie)
+  };
+}));
+var layerSocketServer = /* @__PURE__ */ Effect.gen(function* () {
+  const config = yield* ShardingConfig.ShardingConfig;
+  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress);
+  if (Option.isNone(listenAddress)) {
+    return yield* Effect.die("layerSocketServer: ShardingConfig.runnerListenAddress is None");
+  }
+  return layer(listenAddress.value);
+}).pipe(Layer.unwrap);
+
+export {
+  layerClientProtocol,
+  layerSocketServer,
+  NodeClusterSocket_exports
+};