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

package/dist/vendor/chunk-HYPKWCVW.js

@@ -0,0 +1,374 @@
+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/BunDatagramSocket.js
+var BunDatagramSocket_exports = {};
+__export(BunDatagramSocket_exports, {
+  fromUdpSocket: () => fromUdpSocket,
+  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 Predicate from "effect/Predicate";
+import * as DatagramSocket from "effect/socket/DatagramSocket";
+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 fromUdpSocket = (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 scopeIdsFor = (family) => {
+  if (family === "ipv4" || process.platform === "win32") return noScopeIds;
+  try {
+    return NetAddress.scopeIdsFromInterfaces(Object.entries(Os.networkInterfaces()));
+  } catch {
+    return noScopeIds;
+  }
+};
+var familyOf = (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 formatHost = (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) => {
+  if (typeof address !== "string") return Effect.undefined;
+  const literal = familyOf(address);
+  if (literal !== void 0) return Effect.succeed({
+    host: address,
+    family: literal
+  });
+  return Effect.callback((resume) => {
+    const fail2 = (error) => resume(Effect.fail(openError(error, "AddressNotAvailable")));
+    try {
+      Dns.lookup(address, {
+        all: true,
+        family: family === "ipv4" ? 4 : family === "ipv6" ? 6 : 0
+      }, (error, results) => {
+        if (error) return fail2(error);
+        const result = results.find((result2) => result2.family === 4) ?? results[0];
+        if (result === void 0) return fail2(new Error(`${address} has no addresses`));
+        resume(Effect.succeed({
+          host: result.address,
+          family: result.family === 6 ? "ipv6" : "ipv4"
+        }));
+      });
+    } catch (error) {
+      fail2(error);
+    }
+  });
+};
+var resolveOpen = /* @__PURE__ */ Effect.fnUntraced(function* (options) {
+  const bind = options.bind;
+  const remote = options.connect ?? options.peer;
+  const fixed = options.family ?? (bind?.address === void 0 ? void 0 : familyOf(bind.address));
+  const resolvedRemote = yield* resolve(remote?.address, fixed);
+  const remoteFamily = resolvedRemote?.family ?? (remote === void 0 ? void 0 : familyOf(remote.address));
+  const resolvedBind = yield* resolve(bind?.address, fixed ?? remoteFamily);
+  const family = fixed ?? remoteFamily ?? resolvedBind?.family ?? "ipv4";
+  const scopeIds = scopeIdsFor(family);
+  return {
+    scopeIds,
+    host: resolvedBind?.host ?? (bind === void 0 ? void 0 : formatHost(bind, scopeIds)) ?? (family === "ipv6" ? "::" : "0.0.0.0"),
+    remote: remote === void 0 ? void 0 : {
+      host: resolvedRemote?.host ?? formatHost(remote, scopeIds),
+      port: remote.port
+    }
+  };
+});
+var errorCode = (error) => Predicate.hasProperty(error, "code") ? 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 writeError = (error) => new DatagramSocket.DatagramSocketError({
+  reason: new DatagramSocket.DatagramSocketWriteError({
+    kind: ioKind(error),
+    cause: error
+  })
+});
+var readError = (error) => new DatagramSocket.DatagramSocketError({
+  reason: new DatagramSocket.DatagramSocketReadError({
+    kind: ioKind(error),
+    cause: error
+  })
+});
+var isClosedError = (error) => Predicate.hasProperty(error, "message") && error.message === "Socket is closed";
+var LIBUS_SOCKET_REUSE_PORT = 4;
+var LIBUS_SOCKET_IPV6_ONLY = 8;
+var LIBUS_SOCKET_REUSE_ADDR = 16;
+var open = /* @__PURE__ */ Effect.fnUntraced(function* (options, events) {
+  const {
+    host,
+    remote,
+    scopeIds
+  } = yield* resolveOpen(options);
+  const backing = new BunBackingSocket(events);
+  const flags = (options.reusePort ? LIBUS_SOCKET_REUSE_PORT : 0) | (options.ipv6Only ? LIBUS_SOCKET_IPV6_ONLY : 0) | (options.reuseAddress ? LIBUS_SOCKET_REUSE_ADDR : 0);
+  const connect = options.connect === void 0 ? void 0 : {
+    hostname: remote.host,
+    port: remote.port
+  };
+  const socket = yield* Effect.tryPromise({
+    try: () => Bun.udpSocket({
+      hostname: host,
+      port: options.bind?.port ?? 0,
+      socket: backing.handlers,
+      ...flags === 0 ? void 0 : {
+        flags
+      },
+      ...connect === void 0 ? void 0 : {
+        connect
+      }
+    }),
+    catch: (error) => openError(error)
+  });
+  backing.socket = socket;
+  yield* Effect.try({
+    try: () => {
+      backing.attach(socket, scopeIds, remote, connect !== void 0);
+      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) => openError(error)
+  }).pipe(Effect.onError(() => Effect.sync(() => backing.close())));
+  return backing;
+});
+var adopt = (socket, options, events) => {
+  const backing = new BunBackingSocket(events);
+  backing.socket = socket;
+  return Effect.gen(function* () {
+    if (socket.closed) return yield* Effect.fail(openError(new Error("The adopted Bun UDP socket is closed")));
+    const family = yield* Effect.try({
+      try: () => {
+        socket.reload({
+          socket: backing.handlers
+        });
+        return socket.address.family === "IPv6" ? "ipv6" : "ipv4";
+      },
+      catch: (error) => openError(error)
+    });
+    const scopeIds = scopeIdsFor(family);
+    const remote = "remoteAddress" in socket ? socket.remoteAddress : void 0;
+    if (remote !== void 0) {
+      return backing.attach(socket, scopeIds, {
+        host: remote.address,
+        port: remote.port
+      }, true);
+    }
+    const peer = options.peer;
+    const resolved = yield* resolve(peer?.address, family);
+    return backing.attach(socket, scopeIds, peer === void 0 ? void 0 : {
+      host: resolved?.host ?? formatHost(peer, scopeIds),
+      port: peer.port
+    }, false);
+  }).pipe(Effect.onError(() => Effect.sync(() => backing.close())));
+};
+var BunBackingSocket = class {
+  events;
+  // installed when the socket is created, so packets can arrive before `attach`
+  handlers;
+  socket = void 0;
+  address = {
+    host: "",
+    port: 0
+  };
+  scopeIds = noScopeIds;
+  peer = void 0;
+  connected = false;
+  // entries per datagram in `sendMany`'s flat list
+  stride = 3;
+  // waiting sends, oldest first; later sends queue behind them to keep order
+  waiting = [];
+  closing = false;
+  constructor(events) {
+    this.events = events;
+    this.handlers = {
+      data: (_socket, payload, port, host) => events.onPacket(payload, host, port),
+      // also fires once right after creation, when nothing is waiting
+      drain: () => this.flush(),
+      // Bun crashes the process without an `error` handler. It passes the
+      // error alone, despite the declared `(socket, error)`.
+      error: (first, second) => this.onNativeError(second === void 0 ? first : second)
+    };
+  }
+  attach(socket, scopeIds, peer, connected) {
+    this.socket = socket;
+    this.address = {
+      host: socket.address.address,
+      port: socket.address.port
+    };
+    this.scopeIds = scopeIds;
+    this.peer = peer;
+    this.connected = connected;
+    this.stride = connected ? 1 : 3;
+    return this;
+  }
+  send(payload, destination, done) {
+    const entries = destination === void 0 ? [payload] : [payload, destination.port, destination.host];
+    if (this.waiting.length !== 0) return this.wait(entries, done);
+    let sent;
+    try {
+      sent = destination === void 0 ? this.socket.send(payload) : this.socket.send(payload, destination.port, destination.host);
+    } catch (error) {
+      return done(this.sendError(error));
+    }
+    if (sent) return done();
+    this.wait(entries, done);
+  }
+  sendMany(payloads, destinations, done) {
+    let entries = payloads;
+    if (!this.connected) {
+      const flat = new Array(payloads.length * 3);
+      for (let i = 0; i < payloads.length; i++) {
+        flat[i * 3] = payloads[i];
+        flat[i * 3 + 1] = destinations[i].port;
+        flat[i * 3 + 2] = destinations[i].host;
+      }
+      entries = flat;
+    }
+    if (this.waiting.length !== 0) return this.wait(entries, done);
+    let sent;
+    try {
+      sent = this.socket.sendMany(entries);
+    } catch (error) {
+      return done(this.sendError(error));
+    }
+    if (sent === payloads.length) return done();
+    this.wait(entries.slice(sent * this.stride), done);
+  }
+  joinMulticast({
+    group,
+    interface: ingress,
+    source
+  }) {
+    return Effect.try({
+      try: () => {
+        const socket = this.socket;
+        const groupHost = NetAddress.formatIp(group);
+        const interfaceHost = ingress === void 0 ? void 0 : NetAddress.formatMulticastInterface(ingress, this.scopeIds);
+        if (source === void 0) {
+          if (!socket.addMembership(groupHost, interfaceHost)) throw new Error(`Could not join ${groupHost}`);
+          return () => Effect.sync(() => socket.dropMembership(groupHost, interfaceHost));
+        }
+        const sourceHost = NetAddress.formatIp(source);
+        if (!socket.addSourceSpecificMembership(sourceHost, groupHost, interfaceHost)) {
+          throw new Error(`Could not join ${groupHost} from ${sourceHost}`);
+        }
+        return () => Effect.sync(() => socket.dropSourceSpecificMembership(sourceHost, groupHost, interfaceHost));
+      },
+      catch: (error) => openError(error)
+    });
+  }
+  close() {
+    if (this.closing) return;
+    this.closing = true;
+    this.failWaiting();
+    try {
+      this.socket?.close();
+    } catch {
+    }
+  }
+  wait(entries, done) {
+    if (this.socket?.closed) {
+      this.closedUnderneath();
+      return done(closedError());
+    }
+    this.waiting.push({
+      entries,
+      done
+    });
+  }
+  // on `drain`, send what the kernel refused, in order, until it refuses again
+  flush() {
+    const socket = this.socket;
+    if (socket === void 0) return;
+    while (!this.closing && this.waiting.length !== 0) {
+      const next = this.waiting[0];
+      let sent;
+      try {
+        sent = socket.sendMany(next.entries);
+      } catch (error) {
+        this.waiting.shift();
+        next.done(this.sendError(error));
+        continue;
+      }
+      const rest = sent * this.stride;
+      if (rest < next.entries.length) {
+        next.entries = next.entries.slice(rest);
+        return;
+      }
+      this.waiting.shift();
+      next.done();
+    }
+  }
+  sendError(error) {
+    if (this.socket?.closed || isClosedError(error)) {
+      this.closedUnderneath();
+      return closedError();
+    }
+    return writeError(error);
+  }
+  onNativeError(error) {
+    if (this.closing) return;
+    if (this.socket?.closed) return this.closedUnderneath();
+    this.events.onError(readError(error));
+  }
+  closedUnderneath() {
+    if (this.closing) return;
+    this.closing = true;
+    this.failWaiting();
+    this.events.onClose();
+  }
+  failWaiting() {
+    const waiting = this.waiting;
+    this.waiting = [];
+    for (let i = 0; i < waiting.length; i++) waiting[i].done(closedError());
+  }
+};
+
+export {
+  make,
+  fromUdpSocket,
+  layer,
+  BunDatagramSocket_exports
+};

package/dist/vendor/chunk-IJON5WTO.js

@@ -0,0 +1,34 @@
+import {
+  layer as layer5
+} from "./chunk-D6XNHJPW.js";
+import {
+  layer as layer6
+} from "./chunk-HXGVOKHF.js";
+import {
+  layer as layer4
+} from "./chunk-7ZKNPDTP.js";
+import {
+  layer
+} from "./chunk-IXI7RW3A.js";
+import {
+  layer as layer2
+} from "./chunk-2ADOI6ZN.js";
+import {
+  layer as layer3
+} from "./chunk-QR2ZOVOL.js";
+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/BunServices.js
+var BunServices_exports = {};
+__export(BunServices_exports, {
+  layer: () => layer7
+});
+import * as Layer from "effect/Layer";
+var layer7 = /* @__PURE__ */ layer.pipe(/* @__PURE__ */ Layer.provideMerge(/* @__PURE__ */ Layer.mergeAll(layer3, layer2, layer4, layer5, layer6)));
+
+export {
+  layer7 as layer,
+  BunServices_exports
+};