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

package/dist/vendor/chunk-CIB6JB2Y.js

@@ -0,0 +1,63 @@
+import {
+  layerClientProtocol,
+  layerSocketServer
+} from "./chunk-Y35ZAO5U.js";
+import {
+  layer
+} from "./chunk-6TZ7LQAC.js";
+import {
+  layer as layer2
+} from "./chunk-MSWDMTAF.js";
+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/BunClusterSocket.js
+var BunClusterSocket_exports = {};
+__export(BunClusterSocket_exports, {
+  layer: () => layer8,
+  layerClientProtocol: () => layerClientProtocol,
+  layerK8sHttpClient: () => layerK8sHttpClient,
+  layerSocketServer: () => layerSocketServer
+});
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as Layer from "effect/Layer";
+import * as K8sHttpClient from "effect/unstable/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/unstable/cluster/MessageStorage";
+import * as RunnerHealth from "effect/unstable/cluster/RunnerHealth";
+import * as Runners from "effect/unstable/cluster/Runners";
+import * as RunnerStorage from "effect/unstable/cluster/RunnerStorage";
+import * as ShardingConfig from "effect/unstable/cluster/ShardingConfig";
+import * as SocketRunner from "effect/unstable/cluster/SocketRunner";
+import * as SqlMessageStorage from "effect/unstable/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/unstable/cluster/SqlRunnerStorage";
+import * as FetchHttpClient from "effect/unstable/http/FetchHttpClient";
+import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+var layer8 = (options) => {
+  const layer9 = options?.clientOnly ? Layer.provide(SocketRunner.layerClientOnly, layerClientProtocol) : Layer.provide(SocketRunner.layer, [layerSocketServer, layerClientProtocol]);
+  const runnerHealth = options?.clientOnly ? Layer.empty : options?.runnerHealth === "k8s" ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(Layer.provide([layer2, layerK8sHttpClient])) : RunnerHealth.layerPing.pipe(Layer.provide(Runners.layerRpc), Layer.provide(layerClientProtocol));
+  return layer9.pipe(Layer.provide(runnerHealth), Layer.provideMerge(options?.storage === "local" ? MessageStorage.layerNoop : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlMessageStorage.layer).pipe(Layer.provide(layer))), Layer.provide(options?.storage === "local" ? RunnerStorage.layerMemory : options?.storage === "byo" ? Layer.empty : Layer.orDie(SqlRunnerStorage.layer)), Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)), Layer.provide(options?.serialization === "ndjson" ? RpcSerialization.layerNdjsonWith({
+    maxBufferSize: options?.serializationMaxBufferSize
+  }) : RpcSerialization.layerSchemaBinary({
+    maxFrameSize: options?.serializationMaxBufferSize
+  })));
+};
+var layerK8sHttpClient = /* @__PURE__ */ K8sHttpClient.layer.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.unwrap(/* @__PURE__ */ Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const caCertOption = yield* fs.readFile("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(Effect.option);
+  if (caCertOption._tag === "None") {
+    return FetchHttpClient.layer;
+  }
+  return Layer.fresh(FetchHttpClient.layer).pipe(Layer.provide(Layer.succeed(FetchHttpClient.RequestInit, {
+    tls: {
+      ca: caCertOption.value
+    }
+  })));
+}))), /* @__PURE__ */ Layer.provide(layer2));
+
+export {
+  layer8 as layer,
+  layerK8sHttpClient,
+  BunClusterSocket_exports
+};

package/dist/vendor/chunk-DS7GF46S.js

@@ -0,0 +1,34 @@
+import {
+  fromDuplex,
+  fromReadable,
+  fromReadableChannel,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toArrayBuffer,
+  toReadable,
+  toReadableNever,
+  toString,
+  toUint8Array
+} from "./chunk-XH4U3JSV.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/NodeStream.js
+var NodeStream_exports = {};
+__export(NodeStream_exports, {
+  fromDuplex: () => fromDuplex,
+  fromReadable: () => fromReadable,
+  fromReadableChannel: () => fromReadableChannel,
+  pipeThroughDuplex: () => pipeThroughDuplex,
+  pipeThroughSimple: () => pipeThroughSimple,
+  toArrayBuffer: () => toArrayBuffer,
+  toReadable: () => toReadable,
+  toReadableNever: () => toReadableNever,
+  toString: () => toString,
+  toUint8Array: () => toUint8Array
+});
+
+export {
+  NodeStream_exports
+};

package/dist/vendor/chunk-DVOAHXPG.js

@@ -0,0 +1,104 @@
+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/NodeWorkerRunner.js
+var NodeWorkerRunner_exports = {};
+__export(NodeWorkerRunner_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 * 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";
+import * as WorkerThreads from "node:worker_threads";
+var layer = /* @__PURE__ */ Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
+  start() {
+    return Effect.gen(function* () {
+      if (!WorkerThreads.parentPort && !process.send) {
+        return yield* new WorkerError({
+          reason: new WorkerSpawnError({
+            message: "not in a worker"
+          })
+        });
+      }
+      const sendRaw = WorkerThreads.parentPort ? (_portId, message, transfers) => WorkerThreads.parentPort.postMessage(message, transfers) : (_portId, message, _transfers) => process.send(message);
+      const sendUnsafe = (_portId, message, transfers) => sendRaw(_portId, [1, message], transfers);
+      const send = (_portId, message, transfers) => Effect.sync(() => sendUnsafe(_portId, message, transfers));
+      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));
+          }
+        };
+        const port = WorkerThreads.parentPort ?? process;
+        function onMessage(message) {
+          if (message[0] === 0) {
+            const result = handler(0, message[1]);
+            if (Effect.isEffect(result)) {
+              const fiber = runFork(result);
+              fiber.addObserver(onExit);
+              trackFiber(fiber);
+            }
+          } else {
+            if (WorkerThreads.parentPort) {
+              WorkerThreads.parentPort.close();
+            } else {
+              process.channel?.unref();
+            }
+            Deferred.doneUnsafe(closeLatch, Exit.void);
+          }
+        }
+        port.on("message", onMessage);
+        function onMessageError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received messageerror event",
+              cause
+            })
+          }));
+        }
+        function onError(cause) {
+          Deferred.doneUnsafe(closeLatch, new WorkerError({
+            reason: new WorkerReceiveError({
+              message: "received error event",
+              cause
+            })
+          }));
+        }
+        if (WorkerThreads.parentPort) {
+          WorkerThreads.parentPort.on("messageerror", onMessageError);
+          WorkerThreads.parentPort.on("error", onError);
+        }
+        yield* Scope.addFinalizer(scope, Effect.sync(() => {
+          port.off("message", onMessage);
+          if (WorkerThreads.parentPort) {
+            WorkerThreads.parentPort.off("messageerror", onMessageError);
+            WorkerThreads.parentPort.off("error", onError);
+          }
+        }));
+        sendRaw(0, [0]);
+        return yield* Deferred.await(closeLatch);
+      }));
+      return {
+        run,
+        send,
+        sendUnsafe
+      };
+    });
+  }
+});
+
+export {
+  layer,
+  NodeWorkerRunner_exports
+};

package/dist/vendor/chunk-DWSHTSVX.js

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

package/dist/vendor/chunk-EGBNVEEW.js

@@ -0,0 +1,14 @@
+// ../../../../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/internal/nodeChildProcessSpawner.js
+var buildSpawnOptions = (options, base, platform) => {
+  const detached = options.detached ?? platform !== "win32";
+  return {
+    ...base,
+    detached,
+    shell: options.shell,
+    windowsHide: options.windowsHide ?? !detached
+  };
+};
+
+export {
+  buildSpawnOptions
+};

package/dist/vendor/chunk-EHDTBBPL.js

@@ -0,0 +1,45 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+} from "./chunk-JJ24ARBQ.js";
+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/BunSocket.js
+var BunSocket_exports = {};
+__export(BunSocket_exports, {
+  NetSocket: () => NetSocket,
+  NodeWS: () => NodeWS,
+  fromDuplex: () => fromDuplex,
+  layerNet: () => layerNet,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  layerWebSocketConstructor: () => layerWebSocketConstructor,
+  makeNet: () => makeNet,
+  makeNetChannel: () => makeNetChannel,
+  makeTls: () => makeTls,
+  makeTlsChannel: () => makeTlsChannel
+});
+import { flow } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/unstable/socket/Socket";
+var layerWebSocketConstructor = /* @__PURE__ */ Layer.succeed(Socket.WebSocketConstructor)((url, options) => (
+  // Bun accepts `WebSocketOptions`, but `bun-types` selects the DOM overload
+  // when `lib.dom` is loaded and hides those constructor options.
+  new globalThis.WebSocket(url, options)
+));
+var layerWebSocket = /* @__PURE__ */ flow(Socket.makeWebSocket, /* @__PURE__ */ Layer.effect(Socket.Socket), /* @__PURE__ */ Layer.provide(layerWebSocketConstructor));
+
+export {
+  layerWebSocketConstructor,
+  layerWebSocket,
+  BunSocket_exports
+};

package/dist/vendor/chunk-EZWY45HP.js

@@ -0,0 +1,18 @@
+import {
+  runMain
+} from "./chunk-LEUPYT3Q.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/NodeRuntime.js
+var NodeRuntime_exports = {};
+__export(NodeRuntime_exports, {
+  runMain: () => runMain2
+});
+var runMain2 = runMain;
+
+export {
+  runMain2 as runMain,
+  NodeRuntime_exports
+};