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

package/dist/vendor/chunk-JJ24ARBQ.js

@@ -0,0 +1,394 @@
+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/NodeSocket.js
+var NodeSocket_exports = {};
+__export(NodeSocket_exports, {
+  NetSocket: () => NetSocket,
+  NodeWS: () => NodeWS,
+  fromDuplex: () => fromDuplex,
+  layerNet: () => layerNet,
+  layerTls: () => layerTls,
+  makeNet: () => makeNet,
+  makeNetChannel: () => makeNetChannel,
+  makeTls: () => makeTls,
+  makeTlsChannel: () => makeTlsChannel
+});
+import * as Arr from "effect/Array";
+import * as Channel from "effect/Channel";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Function from "effect/Function";
+import { identity } from "effect/Function";
+import * as Latch from "effect/Latch";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import * as Scope from "effect/Scope";
+import * as Socket from "effect/unstable/socket/Socket";
+import { Buffer } from "node:buffer";
+import * as Net from "node:net";
+import * as Tls from "node:tls";
+import * as NodeWS from "ws";
+var isDeno = "Deno" in globalThis;
+var NetSocket = class extends (/* @__PURE__ */ Context.Service()("@effect/platform-node/NodeSocket/NetSocket")) {
+};
+var readAvailable = (conn) => {
+  const first = conn.read();
+  if (first === null) return null;
+  const second = conn.read();
+  if (second === null) return [first];
+  const out = [first, second];
+  let chunk;
+  while ((chunk = conn.read()) !== null) {
+    out.push(chunk);
+  }
+  return out;
+};
+var toBuffers = (input) => Arr.map(Arr.ensure(input), (value2) => Buffer.from(value2));
+var closeSocket = (conn, isOpen) => {
+  if (conn.closed !== false) return;
+  if (!isOpen || !("destroySoon" in conn)) {
+    conn.destroy();
+  } else {
+    conn.destroySoon();
+  }
+};
+var makeNet = (options) => fromDuplex(Effect.contextWith((context) => {
+  let conn;
+  let isOpen = false;
+  return Effect.flatMap(Scope.addFinalizer(Context.get(context, Scope.Scope), Effect.sync(() => {
+    if (!conn) return;
+    closeSocket(conn, isOpen);
+  })), () => Effect.callback((resume) => {
+    conn = Net.createConnection(options);
+    conn.once("connect", () => {
+      isOpen = true;
+      resume(Effect.succeed(conn));
+    });
+    conn.on("error", (cause) => {
+      resume(Effect.fail(new Socket.SocketError({
+        reason: new Socket.SocketOpenError({
+          kind: "Unknown",
+          cause
+        })
+      })));
+    });
+  }));
+}), options);
+var fromDuplex = (open, options) => Effect.withFiber((fiber) => {
+  let currentSocket;
+  const latch = Latch.makeUnsafe(false);
+  const openServices = fiber.context;
+  const isServer = options?.tlsServer === true;
+  const secureEvent = isServer ? "secure" : "secureConnect";
+  const reader = Effect.gen(function* () {
+    const scope2 = yield* Effect.scope;
+    let conn = yield* Scope.provide(open, scope2).pipe(options?.openTimeout !== void 0 ? Effect.timeoutOrElse({
+      duration: options.openTimeout,
+      orElse: () => Effect.fail(new Socket.SocketError({
+        reason: new Socket.SocketOpenError({
+          kind: "Timeout",
+          cause: new Error("Connection timed out")
+        })
+      }))
+    }) : identity);
+    let error;
+    let waiter;
+    let upgradeAvailable = true;
+    function fail2(err) {
+      if (error === void 0) error = err;
+      if (waiter !== void 0) {
+        const resume = waiter;
+        waiter = void 0;
+        resume(Effect.fail(error));
+      }
+    }
+    function onReadable() {
+      if (waiter === void 0) return;
+      const chunk = readAvailable(conn);
+      if (chunk === null) return;
+      const resume = waiter;
+      waiter = void 0;
+      resume(Effect.succeed(chunk));
+    }
+    function onEnd() {
+      fail2(new Socket.SocketError({
+        reason: new Socket.SocketCloseError({
+          code: 1e3
+        })
+      }));
+    }
+    function onError(cause) {
+      fail2(new Socket.SocketError({
+        reason: new Socket.SocketReadError({
+          cause
+        })
+      }));
+    }
+    function onClose(hadError) {
+      fail2(new Socket.SocketError({
+        reason: new Socket.SocketCloseError({
+          code: hadError ? 1006 : 1e3
+        })
+      }));
+    }
+    function attachReadListeners(conn2) {
+      conn2.on("readable", onReadable);
+      conn2.on("end", onEnd);
+      conn2.on("error", onError);
+      conn2.on("close", onClose);
+    }
+    function detachReadListeners(conn2) {
+      conn2.off("readable", onReadable);
+      conn2.off("end", onEnd);
+      conn2.off("error", onError);
+      conn2.off("close", onClose);
+    }
+    if (!isDeno) conn.pause();
+    attachReadListeners(conn);
+    yield* Scope.addFinalizer(scope2, Effect.sync(() => {
+      fail2(new Socket.SocketError({
+        reason: new Socket.SocketCloseError({
+          code: 1006
+        })
+      }));
+      detachReadListeners(conn);
+      latch.closeUnsafe();
+      currentSocket = void 0;
+      upgradeAvailable = false;
+    }));
+    currentSocket = conn;
+    latch.openUnsafe();
+    const pull = Effect.suspend(() => {
+      const chunk = readAvailable(conn);
+      if (chunk !== null) return Effect.succeed(chunk);
+      if (error !== void 0) return Effect.fail(error);
+      return Effect.callback((resume) => {
+        waiter = resume;
+        return Effect.sync(() => {
+          if (waiter === resume) waiter = void 0;
+        });
+      });
+    });
+    const upgrade = (upgradeOptions = {}) => Effect.suspend(() => {
+      if (!upgradeAvailable) {
+        return Effect.fail(new Socket.SocketError({
+          reason: new Socket.SocketUpgradeError({
+            cause: new Error("socket is already upgraded or closed")
+          })
+        }));
+      }
+      const hasKey = upgradeOptions.key !== void 0;
+      const hasCert = upgradeOptions.cert !== void 0;
+      if (isServer && (!hasKey || !hasCert) || hasKey !== hasCert) {
+        return Effect.fail(new Socket.SocketError({
+          reason: new Socket.SocketUpgradeError({
+            cause: new Error(isServer ? "server TLS upgrade requires both key and cert" : "TLS upgrade credentials must include both key and cert")
+          })
+        }));
+      }
+      return Effect.callback((resume) => {
+        const raw = conn;
+        detachReadListeners(raw);
+        let tls;
+        try {
+          const secureContext = Tls.createSecureContext({
+            key: upgradeOptions.key === void 0 ? void 0 : Arr.map(Arr.ensure(upgradeOptions.key), (value2) => Buffer.from(Redacted.value(value2))),
+            cert: upgradeOptions.cert === void 0 ? void 0 : toBuffers(upgradeOptions.cert),
+            ca: upgradeOptions.ca === void 0 ? void 0 : toBuffers(upgradeOptions.ca),
+            passphrase: upgradeOptions.passphrase === void 0 ? void 0 : Redacted.value(upgradeOptions.passphrase)
+          });
+          const tlsOptions = {
+            secureContext,
+            ALPNProtocols: upgradeOptions.alpnProtocols === void 0 ? void 0 : [...upgradeOptions.alpnProtocols],
+            requestCert: upgradeOptions.requestCert,
+            rejectUnauthorized: upgradeOptions.rejectUnauthorized
+          };
+          tls = isServer ? new Tls.TLSSocket(raw, {
+            ...tlsOptions,
+            isServer: true
+          }) : Tls.connect({
+            ...tlsOptions,
+            socket: raw
+          });
+        } catch (cause) {
+          attachReadListeners(raw);
+          resume(Effect.fail(new Socket.SocketError({
+            reason: new Socket.SocketUpgradeError({
+              cause
+            })
+          })));
+          return;
+        }
+        conn = tls;
+        currentSocket = tls;
+        tls.pause();
+        function cleanup() {
+          tls.off(secureEvent, succeed2);
+          tls.off("error", failUpgrade);
+          tls.off("close", onUpgradeClose);
+        }
+        function succeed2() {
+          cleanup();
+          upgradeAvailable = false;
+          attachReadListeners(tls);
+          resume(Effect.void);
+        }
+        function failUpgrade(cause) {
+          cleanup();
+          const upgradeError = new Socket.SocketError({
+            reason: new Socket.SocketUpgradeError({
+              cause
+            })
+          });
+          fail2(upgradeError);
+          resume(Effect.fail(upgradeError));
+        }
+        function onUpgradeClose() {
+          failUpgrade(new Error("socket closed during TLS upgrade"));
+        }
+        tls.once(secureEvent, succeed2);
+        tls.once("error", failUpgrade);
+        tls.once("close", onUpgradeClose);
+        return Effect.sync(() => {
+          cleanup();
+          fail2(new Socket.SocketError({
+            reason: new Socket.SocketCloseError({
+              code: 1006
+            })
+          }));
+          tls.destroy();
+        });
+      });
+    });
+    return {
+      pull,
+      upgrade
+    };
+  }).pipe(Effect.updateContext((input) => Context.merge(openServices, input)));
+  const awaitDrain = (conn) => Effect.callback((resume) => {
+    function cleanup() {
+      conn.off("drain", onDrain);
+      conn.off("error", onError);
+      conn.off("close", onClose);
+    }
+    function onDrain() {
+      cleanup();
+      resume(Effect.void);
+    }
+    function onError(cause) {
+      cleanup();
+      resume(Effect.fail(new Socket.SocketError({
+        reason: new Socket.SocketWriteError({
+          cause
+        })
+      })));
+    }
+    function onClose() {
+      cleanup();
+      resume(Effect.fail(new Socket.SocketError({
+        reason: new Socket.SocketWriteError({
+          cause: new Error("socket closed")
+        })
+      })));
+    }
+    conn.on("drain", onDrain);
+    conn.on("error", onError);
+    conn.on("close", onClose);
+    return Effect.sync(cleanup);
+  });
+  const write = (chunk) => Effect.suspend(() => {
+    const conn = currentSocket;
+    if (conn === void 0) return latch.whenOpen(write(chunk));
+    if (Socket.isCloseEvent(chunk)) {
+      conn.destroy(chunk.code > 1e3 ? new Error(`closed with code ${chunk.code}`) : void 0);
+      return Effect.void;
+    }
+    try {
+      return conn.write(chunk) ? Effect.void : awaitDrain(conn);
+    } catch (cause) {
+      return Effect.fail(new Socket.SocketError({
+        reason: new Socket.SocketWriteError({
+          cause
+        })
+      }));
+    }
+  });
+  const writeAll = (chunks) => Effect.suspend(() => {
+    const conn = currentSocket;
+    if (conn === void 0) return latch.whenOpen(writeAll(chunks));
+    let needsDrain = false;
+    try {
+      if (chunks.length === 1) {
+        needsDrain = !conn.write(chunks[0]);
+      } else {
+        conn.cork();
+        try {
+          for (let i = 0; i < chunks.length; i++) {
+            needsDrain = !conn.write(chunks[i]) || needsDrain;
+          }
+        } finally {
+          conn.uncork();
+        }
+      }
+    } catch (cause) {
+      return Effect.fail(new Socket.SocketError({
+        reason: new Socket.SocketWriteError({
+          cause
+        })
+      }));
+    }
+    return needsDrain ? awaitDrain(conn) : Effect.void;
+  });
+  const writer = Effect.acquireRelease(Effect.succeed({
+    write,
+    writeAll
+  }), () => Effect.sync(() => {
+    if (!currentSocket || currentSocket.writableEnded) return;
+    currentSocket.end();
+  }));
+  return Effect.succeed(Socket.make({
+    reader,
+    writer
+  }));
+});
+var makeNetChannel = (options) => Channel.unwrap(Effect.map(makeNet(options), Socket.toChannelWith()));
+var layerNet = /* @__PURE__ */ Function.flow(makeNet, /* @__PURE__ */ Layer.effect(Socket.Socket));
+var makeTls = (options) => fromDuplex(Effect.contextWith((context) => {
+  let conn;
+  let isOpen = false;
+  return Effect.flatMap(Scope.addFinalizer(Context.get(context, Scope.Scope), Effect.sync(() => {
+    if (!conn) return;
+    closeSocket(conn, isOpen);
+  })), () => Effect.callback((resume) => {
+    conn = Tls.connect(options);
+    conn.once("secureConnect", () => {
+      isOpen = true;
+      resume(Effect.succeed(conn));
+    });
+    conn.on("error", (cause) => {
+      resume(Effect.fail(new Socket.SocketError({
+        reason: new Socket.SocketOpenError({
+          kind: "Unknown",
+          cause
+        })
+      })));
+    });
+  }));
+}), options);
+var makeTlsChannel = (options) => Channel.unwrap(Effect.map(makeTls(options), Socket.toChannelWith()));
+var layerTls = /* @__PURE__ */ Function.flow(makeTls, /* @__PURE__ */ Layer.effect(Socket.Socket));
+
+export {
+  NetSocket,
+  makeNet,
+  fromDuplex,
+  makeNetChannel,
+  layerNet,
+  makeTls,
+  makeTlsChannel,
+  layerTls,
+  NodeSocket_exports,
+  NodeWS
+};