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

package/dist/vendor/chunk-TCKM3JXD.js

@@ -0,0 +1,325 @@
+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/NodeDatagramSocket.js
+var NodeDatagramSocket_exports = {};
+__export(NodeDatagramSocket_exports, {
+  fromSocket: () => fromSocket,
+  layer: () => layer,
+  make: () => make
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as NetAddress from "effect/net/NetAddress";
+import * as DatagramSocket from "effect/socket/DatagramSocket";
+import * as Dgram from "node:dgram";
+import * as Dns from "node:dns";
+import * as Net from "node:net";
+import * as Os from "node:os";
+var make = (options = {}) => DatagramSocket.makeFromBackingSocket((events) => open(options, events), options);
+var fromSocket = (acquire, options = {}) => DatagramSocket.makeFromBackingSocket((events) => Effect.flatMap(acquire, (socket) => adopt(socket, options, events)), options);
+var layer = (options) => Layer.effect(DatagramSocket.DatagramSocket, make(options));
+var noScopeIds = /* @__PURE__ */ new Map();
+var interfaceScopeIds = () => {
+  if (process.platform === "win32") return noScopeIds;
+  try {
+    return NetAddress.scopeIdsFromInterfaces(Object.entries(Os.networkInterfaces()));
+  } catch {
+    return noScopeIds;
+  }
+};
+var scopeIdsFor = (family) => family === "ipv6" ? interfaceScopeIds() : noScopeIds;
+var familyOfLiteral = (address) => {
+  if (typeof address !== "string") return NetAddress.isIpv4Address(address) ? "ipv4" : "ipv6";
+  const version = Net.isIP(address);
+  return version === 4 ? "ipv4" : version === 6 ? "ipv6" : void 0;
+};
+var formatEndpoint = (endpoint, scopeIds) => NetAddress.isInetAddress(endpoint) ? NetAddress.formatNativeHost(endpoint, scopeIds) : endpoint.address === void 0 || typeof endpoint.address === "string" ? endpoint.address : NetAddress.formatIp(endpoint.address);
+var resolve = (address, family, onError, next) => {
+  if (typeof address !== "string") return next(void 0);
+  const literal = familyOfLiteral(address);
+  if (literal !== void 0) return next({
+    host: address,
+    family: literal
+  });
+  try {
+    Dns.lookup(address, {
+      all: true,
+      family: family === "ipv4" ? 4 : family === "ipv6" ? 6 : 0
+    }, (error, results) => {
+      if (error) return onError(error);
+      const result = results.find((result2) => result2.family === 4) ?? results[0];
+      if (result === void 0) return onError(new Error(`${address} has no addresses`));
+      next({
+        host: result.address,
+        family: result.family === 6 ? "ipv6" : "ipv4"
+      });
+    });
+  } catch (error) {
+    onError(error);
+  }
+};
+var planOpen = (options, scopeIdsOf, onLookupError, next) => {
+  const {
+    bind: bind2,
+    remote
+  } = options;
+  const fixed = options.family ?? (bind2?.address === void 0 ? void 0 : familyOfLiteral(bind2.address));
+  resolve(remote?.address, fixed, onLookupError, (resolvedRemote) => {
+    const remoteFamily = resolvedRemote?.family ?? (remote === void 0 ? void 0 : familyOfLiteral(remote.address));
+    resolve(bind2?.address, fixed ?? remoteFamily, onLookupError, (resolvedBind) => {
+      const family = fixed ?? remoteFamily ?? resolvedBind?.family ?? "ipv4";
+      const scopeIds = scopeIdsOf(family);
+      next({
+        family,
+        scopeIds,
+        bindHost: resolvedBind?.host ?? (bind2 === void 0 ? void 0 : formatEndpoint(bind2, scopeIds)) ?? (family === "ipv6" ? "::" : "0.0.0.0"),
+        remote: remote === void 0 ? void 0 : {
+          host: resolvedRemote?.host ?? formatEndpoint(remote, scopeIds),
+          port: remote.port
+        }
+      });
+    });
+  });
+};
+var resolvePeer = (peer, family, scopeIds, onLookupError, next) => {
+  if (peer === void 0) return next(void 0);
+  if (typeof peer.address !== "string") return next({
+    host: formatEndpoint(peer, scopeIds),
+    port: peer.port
+  });
+  resolve(peer.address, family, onLookupError, (resolved) => next({
+    host: resolved.host,
+    port: peer.port
+  }));
+};
+var errorCode = (error) => typeof error === "object" && error !== null ? error.code : void 0;
+var openError = (error, kind) => {
+  if (kind === void 0) {
+    const code = errorCode(error);
+    kind = code === "EADDRINUSE" ? "AddressInUse" : code === "EADDRNOTAVAIL" ? "AddressNotAvailable" : code === "EACCES" || code === "EPERM" ? "PermissionDenied" : "Unknown";
+  }
+  return new DatagramSocket.DatagramSocketError({
+    reason: new DatagramSocket.DatagramSocketOpenError({
+      kind,
+      cause: error
+    })
+  });
+};
+var ioKind = (error) => {
+  switch (errorCode(error)) {
+    case "EMSGSIZE":
+      return "MessageTooLarge";
+    case "EHOSTUNREACH":
+    case "ENETUNREACH":
+    case "EHOSTDOWN":
+    case "ENETDOWN":
+      return "Unreachable";
+    case "ECONNREFUSED":
+      return "ConnectionRefused";
+    case "EACCES":
+    case "EPERM":
+      return "PermissionDenied";
+    default:
+      return "Unknown";
+  }
+};
+var closedError = () => new DatagramSocket.DatagramSocketError({
+  reason: new DatagramSocket.DatagramSocketClosedError()
+});
+var ioWriteError = (error, kind = ioKind(error)) => new DatagramSocket.DatagramSocketError({
+  reason: new DatagramSocket.DatagramSocketWriteError({
+    kind,
+    cause: error
+  })
+});
+var readError = (error, kind = ioKind(error)) => new DatagramSocket.DatagramSocketError({
+  reason: new DatagramSocket.DatagramSocketReadError({
+    kind,
+    cause: error
+  })
+});
+var immediateLookup = (hostname, family, callback2) => callback2(null, hostname, family === 6 ? 6 : 4);
+var writeError = (error) => errorCode(error) === "ERR_SOCKET_DGRAM_NOT_RUNNING" ? closedError() : ioWriteError(error);
+var open = (options, events) => (
+  // Core lets uncancellable lookups finish and closes abandoned sockets.
+  Effect.callback((resume) => {
+    planOpen({
+      family: options.family,
+      bind: options.bind,
+      remote: options.connect ?? options.peer
+    }, scopeIdsFor, (error) => resume(Effect.fail(openError(error, "AddressNotAvailable"))), (plan) => bind(options, events, plan, resume));
+  })
+);
+var bind = (options, events, {
+  bindHost: host,
+  family,
+  remote,
+  scopeIds
+}, resume) => {
+  let socket;
+  try {
+    socket = Dgram.createSocket({
+      type: family === "ipv6" ? "udp6" : "udp4",
+      reuseAddr: options.reuseAddress,
+      reusePort: options.reusePort,
+      ipv6Only: options.ipv6Only,
+      lookup: immediateLookup
+    });
+  } catch (error) {
+    return resume(Effect.fail(openError(error)));
+  }
+  const native = new NativeSocket(socket, events);
+  const fail2 = (error) => {
+    native.close();
+    resume(Effect.fail(error));
+  };
+  native.onOpenError = (error) => fail2(openError(error));
+  try {
+    socket.bind({
+      address: host,
+      port: options.bind?.port ?? 0
+    }, () => {
+      try {
+        if (options.kernelReceiveBufferSize !== void 0) socket.setRecvBufferSize(options.kernelReceiveBufferSize);
+        if (options.kernelSendBufferSize !== void 0) socket.setSendBufferSize(options.kernelSendBufferSize);
+        if (options.broadcast !== void 0) socket.setBroadcast(options.broadcast);
+        if (options.ttl !== void 0) socket.setTTL(options.ttl);
+        const multicast = options.multicast;
+        if (multicast?.ttl !== void 0) socket.setMulticastTTL(multicast.ttl);
+        if (multicast?.loopback !== void 0) socket.setMulticastLoopback(multicast.loopback);
+        if (multicast?.interface !== void 0) {
+          socket.setMulticastInterface(NetAddress.formatMulticastInterface(multicast.interface, scopeIds));
+        }
+      } catch (error) {
+        return fail2(openError(error));
+      }
+      if (options.connect === void 0) return resume(Effect.succeed(native.open(scopeIds, remote, false)));
+      try {
+        socket.connect(remote.port, remote.host, (error) => {
+          if (error) return fail2(openError(error));
+          resume(Effect.succeed(native.open(scopeIds, remote, true)));
+        });
+      } catch (error) {
+        fail2(openError(error));
+      }
+    });
+  } catch (error) {
+    fail2(openError(error));
+  }
+};
+var adopt = (socket, options, events) => Effect.callback((resume) => {
+  const native = new NativeSocket(socket, events);
+  const fail2 = (error) => {
+    native.close();
+    resume(Effect.fail(error));
+  };
+  let family;
+  let remote;
+  try {
+    family = socket.address().family === "IPv6" ? "ipv6" : "ipv4";
+  } catch (error) {
+    return fail2(openError(error));
+  }
+  try {
+    remote = socket.remoteAddress();
+  } catch {
+  }
+  const scopeIds = scopeIdsFor(family);
+  if (remote !== void 0) {
+    return resume(Effect.succeed(native.open(scopeIds, {
+      host: remote.address,
+      port: remote.port
+    }, true)));
+  }
+  resolvePeer(options.peer, family, scopeIds, (error) => fail2(openError(error, "AddressNotAvailable")), (peer) => resume(Effect.succeed(native.open(scopeIds, peer, false))));
+});
+var NativeSocket = class {
+  socket;
+  onOpenError = void 0;
+  closing = false;
+  constructor(socket, events) {
+    this.socket = socket;
+    socket.on("message", (payload, info) => events.onPacket(payload, info.address, info.port));
+    socket.on("error", (error) => {
+      if (this.onOpenError !== void 0) return this.onOpenError(error);
+      events.onError(readError(error));
+    });
+    socket.on("close", () => {
+      if (!this.closing) events.onClose();
+    });
+  }
+  open(scopeIds, peer, connected) {
+    this.onOpenError = void 0;
+    const socket = this.socket;
+    const bound = socket.address();
+    const send = (payload, destination, done) => {
+      try {
+        if (destination === void 0) socket.send(payload, done);
+        else socket.send(payload, destination.port, destination.host, done);
+      } catch (error) {
+        done(error);
+      }
+    };
+    return {
+      address: {
+        host: bound.address,
+        port: bound.port
+      },
+      scopeIds,
+      peer,
+      connected,
+      send: (payload, destination, done) => send(payload, destination, (error) => done(error == null ? void 0 : writeError(error))),
+      sendMany: (payloads, destinations, done) => {
+        let remaining = payloads.length;
+        let failure;
+        let failedAt;
+        const report = (error, index) => {
+          if (error != null && failure === void 0) {
+            failure = writeError(error);
+            failedAt = index;
+          }
+          if (--remaining === 0) done(failure, failedAt);
+        };
+        for (let i = 0; i < payloads.length; i++) {
+          send(payloads[i], destinations[i], (error) => report(error, i));
+        }
+      },
+      joinMulticast: ({
+        group,
+        interface: ingress,
+        source
+      }) => Effect.try({
+        try: () => {
+          const groupHost = NetAddress.formatIp(group);
+          const interfaceHost = ingress === void 0 ? void 0 : NetAddress.formatMulticastInterface(ingress, scopeIds);
+          if (source === void 0) {
+            socket.addMembership(groupHost, interfaceHost);
+            return () => Effect.sync(() => socket.dropMembership(groupHost, interfaceHost));
+          }
+          const sourceHost = NetAddress.formatIp(source);
+          socket.addSourceSpecificMembership(sourceHost, groupHost, interfaceHost);
+          return () => Effect.sync(() => socket.dropSourceSpecificMembership(sourceHost, groupHost, interfaceHost));
+        },
+        catch: (error) => openError(error)
+      }),
+      close: () => this.close()
+    };
+  }
+  close() {
+    if (this.closing) return;
+    this.closing = true;
+    try {
+      this.socket.close();
+    } catch {
+    }
+  }
+};
+
+export {
+  make,
+  fromSocket,
+  layer,
+  NodeDatagramSocket_exports
+};

package/dist/vendor/chunk-UXIG7ALP.js

@@ -0,0 +1,229 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex
+} from "./chunk-Q7YXUH7M.js";
+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/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 NetAddress from "effect/net/NetAddress";
+import * as References from "effect/References";
+import * as Scope from "effect/Scope";
+import * as Socket from "effect/socket/Socket";
+import * as SocketServer from "effect/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
+};