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

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

package/dist/vendor/chunk-JUVIPOOR.js

@@ -0,0 +1,18 @@
+import {
+  flattenCommand,
+  layer
+} from "./chunk-IR7WG7SA.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/NodeChildProcessSpawner.js
+var NodeChildProcessSpawner_exports = {};
+__export(NodeChildProcessSpawner_exports, {
+  flattenCommand: () => flattenCommand,
+  layer: () => layer
+});
+
+export {
+  NodeChildProcessSpawner_exports
+};

package/dist/vendor/chunk-KCLEGTEN.js

@@ -0,0 +1,86 @@
+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/BunWorkerRunner.js
+var BunWorkerRunner_exports = {};
+__export(BunWorkerRunner_exports, {
+  layer: () => layer
+});
+import * as Cause from "effect/Cause";
+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 { identity } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Scope from "effect/Scope";
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/unstable/workers/WorkerError";
+import * as WorkerRunner from "effect/unstable/workers/WorkerRunner";
+var layer = /* @__PURE__ */ Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start: /* @__PURE__ */ Effect.fnUntraced(function* () {
+    if (!("postMessage" in self)) {
+      return yield* new WorkerError({
+        reason: new WorkerSpawnError({
+          message: "not in a Worker context"
+        })
+      });
+    }
+    const port = self;
+    const run = (handler) => Effect.scopedWith(Effect.fnUntraced(function* (scope) {
+      const closeLatch = Deferred.makeUnsafe();
+      const trackFiber = Fiber.runIn(scope);
+      const services = yield* Effect.context();
+      const runFork = Effect.runForkWith(services);
+      const onExit = (exit) => {
+        if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
+          runFork(Effect.logError("unhandled error in worker", exit.cause));
+        }
+      };
+      function onMessage(event) {
+        const message = event.data;
+        if (message[0] === 0) {
+          const result = handler(0, message[1]);
+          if (Effect.isEffect(result)) {
+            const fiber = runFork(result);
+            fiber.addObserver(onExit);
+            trackFiber(fiber);
+          }
+        } else {
+          port.close();
+          Deferred.doneUnsafe(closeLatch, Exit.void);
+        }
+      }
+      function onMessageError(error) {
+        Deferred.doneUnsafe(closeLatch, new WorkerError({
+          reason: new WorkerReceiveError({
+            message: "received messageerror event",
+            cause: error.data
+          })
+        }));
+      }
+      yield* Scope.addFinalizer(scope, Effect.sync(() => {
+        port.removeEventListener("message", onMessage);
+        port.removeEventListener("messageerror", onMessageError);
+      }));
+      port.addEventListener("message", onMessage);
+      port.addEventListener("messageerror", onMessageError);
+      port.postMessage([0]);
+      return yield* Deferred.await(closeLatch);
+    }));
+    const sendUnsafe = (_portId, message, transfer) => port.postMessage([1, message], {
+      transfer
+    });
+    const send = (_portId, message, transfer) => Effect.sync(() => sendUnsafe(0, message, transfer));
+    return identity({
+      run,
+      send,
+      sendUnsafe
+    });
+  })
+});
+
+export {
+  layer,
+  BunWorkerRunner_exports
+};