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

package/dist/vendor/chunk-Q7YXUH7M.js

@@ -0,0 +1,414 @@
+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/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/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 void 0;
+  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 pending;
+    let reading = false;
+    let closed = false;
+    let upgradeAvailable = true;
+    function drain() {
+      if (waiter === void 0 || reading) return;
+      let chunk = pending;
+      pending = void 0;
+      if (chunk === void 0 && !closed) {
+        reading = true;
+        try {
+          chunk = readAvailable(conn);
+        } finally {
+          reading = false;
+        }
+      }
+      if (closed) chunk = void 0;
+      if (waiter === void 0) {
+        pending = chunk;
+        return;
+      }
+      const result = chunk !== void 0 ? Effect.succeed(chunk) : error !== void 0 ? Effect.fail(error) : void 0;
+      if (result === void 0) return;
+      const resume = waiter;
+      waiter = void 0;
+      resume(result);
+    }
+    function end(err) {
+      error ??= err;
+      drain();
+    }
+    function close(err) {
+      error ??= err;
+      closed = true;
+      pending = void 0;
+      drain();
+    }
+    function onEnd() {
+      end(new Socket.SocketError({
+        reason: new Socket.SocketCloseError({
+          code: 1e3
+        })
+      }));
+    }
+    function onError(cause) {
+      close(new Socket.SocketError({
+        reason: new Socket.SocketReadError({
+          cause
+        })
+      }));
+    }
+    function onClose(hadError) {
+      const err = new Socket.SocketError({
+        reason: new Socket.SocketCloseError({
+          code: hadError ? 1006 : 1e3
+        })
+      });
+      if (hadError) close(err);
+      else end(err);
+    }
+    function attachReadListeners(conn2) {
+      conn2.on("readable", drain);
+      conn2.on("end", onEnd);
+      conn2.on("error", onError);
+      conn2.on("close", onClose);
+    }
+    function detachReadListeners(conn2) {
+      conn2.off("readable", drain);
+      conn2.off("end", onEnd);
+      conn2.off("error", onError);
+      conn2.off("close", onClose);
+    }
+    if (!isDeno) conn.pause();
+    attachReadListeners(conn);
+    yield* Scope.addFinalizer(scope2, Effect.sync(() => {
+      close(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.callback((resume) => {
+      waiter = resume;
+      drain();
+      if (waiter !== resume) return;
+      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,
+            servername: upgradeOptions.servername,
+            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
+            })
+          });
+          close(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();
+          close(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
+};

package/dist/vendor/chunk-QKYYD3AZ.js

@@ -0,0 +1,131 @@
+import {
+  make
+} from "./chunk-X6FYP2EH.js";
+import {
+  fromReadable,
+  toUint8Array
+} from "./chunk-T5WDTZCE.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_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 Multipart from "effect/http/Multipart";
+import * as MultipartParser from "effect/http/MultipartParser";
+import * as Inspectable from "effect/Inspectable";
+import * as Stream from "effect/Stream";
+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-QLI7T34M.js

@@ -0,0 +1,18 @@
+import {
+  flattenCommand,
+  layer
+} from "./chunk-IXI7RW3A.js";
+import {
+  __export
+} from "./chunk-MLKGABMK.js";
+
+// ../../../../node_modules/.pnpm/@effect+platform-node@4.0.5_effect@4.0.5_redis@6.2.1_@opentelemetry+api@1.9.1_/node_modules/@effect/platform-node/dist/NodeChildProcessSpawner.js
+var NodeChildProcessSpawner_exports = {};
+__export(NodeChildProcessSpawner_exports, {
+  flattenCommand: () => flattenCommand,
+  layer: () => layer
+});
+
+export {
+  NodeChildProcessSpawner_exports
+};

package/dist/vendor/chunk-QR2ZOVOL.js

@@ -0,0 +1,18 @@
+import {
+  layer
+} from "./chunk-7JOAEKDV.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/BunFileSystem.js
+var BunFileSystem_exports = {};
+__export(BunFileSystem_exports, {
+  layer: () => layer2
+});
+var layer2 = layer;
+
+export {
+  layer2 as layer,
+  BunFileSystem_exports
+};