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

package/dist/vendor/chunk-DX4VFONH.js

@@ -0,0 +1,81 @@
+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/NodeSink.js
+var NodeSink_exports = {};
+__export(NodeSink_exports, {
+  fromWritable: () => fromWritable,
+  fromWritableChannel: () => fromWritableChannel,
+  pullIntoWritable: () => pullIntoWritable
+});
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Effect from "effect/Effect";
+import { identity } from "effect/Function";
+import * as Pull from "effect/Pull";
+import * as Sink from "effect/Sink";
+var fromWritable = (options) => Sink.fromChannel(Channel.mapDone(fromWritableChannel(options), (_) => [_]));
+var fromWritableChannel = (options) => Channel.fromTransform((pull) => {
+  const writable = options.evaluate();
+  return Effect.succeed(pullIntoWritable({
+    ...options,
+    writable,
+    pull
+  }));
+});
+var pullIntoWritable = (options) => options.pull.pipe(Effect.flatMap((chunk) => {
+  let i = 0;
+  return Effect.callback((resume) => {
+    let cancelled = false;
+    const loop = () => {
+      for (; i < chunk.length; ) {
+        if (cancelled) {
+          return;
+        }
+        const success = options.writable.write(chunk[i++], options.encoding);
+        if (!success) {
+          if (!cancelled) {
+            options.writable.once("drain", loop);
+          }
+          return;
+        }
+      }
+      if (!cancelled) {
+        resume(Effect.void);
+      }
+    };
+    loop();
+    return Effect.sync(() => {
+      cancelled = true;
+      options.writable.off("drain", loop);
+    });
+  });
+}), Effect.forever({
+  disableYield: true
+}), options.endOnDone !== false ? Pull.catchDone((_) => {
+  if ("closed" in options.writable && options.writable.closed) {
+    return Cause.done(_);
+  }
+  return Effect.callback((resume) => {
+    const onFinish = () => resume(Cause.done(_));
+    options.writable.once("finish", onFinish);
+    options.writable.end();
+    return Effect.sync(() => {
+      options.writable.off("finish", onFinish);
+    });
+  });
+}) : identity, Effect.raceFirst(Effect.callback((resume) => {
+  const onError = (error) => resume(Effect.fail(options.onError(error)));
+  options.writable.once("error", onError);
+  return Effect.sync(() => {
+    options.writable.off("error", onError);
+  });
+})));
+
+export {
+  fromWritable,
+  fromWritableChannel,
+  pullIntoWritable,
+  NodeSink_exports
+};

package/dist/vendor/chunk-EIO7BKW3.js

@@ -0,0 +1,63 @@
+import {
+  layerClientProtocol,
+  layerSocketServer
+} from "./chunk-M2QOSF47.js";
+import {
+  layer
+} from "./chunk-2ADOI6ZN.js";
+import {
+  layer as layer2
+} 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/BunClusterSocket.js
+var BunClusterSocket_exports = {};
+__export(BunClusterSocket_exports, {
+  layer: () => layer8,
+  layerClientProtocol: () => layerClientProtocol,
+  layerK8sHttpClient: () => layerK8sHttpClient,
+  layerSocketServer: () => layerSocketServer
+});
+import * as K8sHttpClient from "effect/cluster/K8sHttpClient";
+import * as MessageStorage from "effect/cluster/MessageStorage";
+import * as RunnerHealth from "effect/cluster/RunnerHealth";
+import * as Runners from "effect/cluster/Runners";
+import * as RunnerStorage from "effect/cluster/RunnerStorage";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import * as SocketRunner from "effect/cluster/SocketRunner";
+import * as SqlMessageStorage from "effect/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage";
+import * as Effect from "effect/Effect";
+import * as FileSystem from "effect/FileSystem";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as Layer from "effect/Layer";
+import * as RpcSerialization from "effect/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-FIPFWLCV.js

@@ -0,0 +1,144 @@
+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/NodeTerminal.js
+var NodeTerminal_exports = {};
+__export(NodeTerminal_exports, {
+  layer: () => layer,
+  make: () => make4
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import { badArgument } from "effect/PlatformError";
+import * as Predicate from "effect/Predicate";
+import * as Queue from "effect/Queue";
+import * as RcRef from "effect/RcRef";
+import * as Terminal from "effect/Terminal";
+import * as readline from "node:readline";
+var make4 = /* @__PURE__ */ Effect.fnUntraced(function* (shouldQuit = defaultShouldQuit) {
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const lines = yield* Queue.make();
+  let inputEnded = stdin.readableEnded;
+  let readlineActive = false;
+  const onStdinEnd = () => {
+    inputEnded = true;
+    if (!readlineActive) {
+      Queue.endUnsafe(lines);
+    }
+  };
+  stdin.once("end", onStdinEnd);
+  yield* Effect.addFinalizer(() => Effect.sync(() => stdin.off("end", onStdinEnd)));
+  const rlRef = yield* RcRef.make({
+    acquire: Effect.acquireRelease(Effect.sync(() => {
+      const rl = readline.createInterface({
+        input: stdin,
+        escapeCodeTimeout: 50
+      });
+      const onLine = (line) => Queue.offerUnsafe(lines, line);
+      const onClose = () => {
+        readlineActive = false;
+        Queue.endUnsafe(lines);
+      };
+      readlineActive = true;
+      readline.emitKeypressEvents(stdin, rl);
+      rl.on("line", onLine);
+      rl.once("close", onClose);
+      if (stdin.isTTY) {
+        stdin.setRawMode(true);
+      }
+      return {
+        rl,
+        onClose,
+        onLine
+      };
+    }), ({
+      rl,
+      onClose,
+      onLine
+    }) => Effect.sync(() => {
+      readlineActive = false;
+      rl.off("line", onLine);
+      rl.off("close", onClose);
+      if (stdin.isTTY) {
+        stdin.setRawMode(false);
+      }
+      rl.close();
+      if (inputEnded) {
+        Queue.endUnsafe(lines);
+      }
+    })),
+    idleTimeToLive: "10 millis"
+  });
+  const columns = Effect.sync(() => stdout.columns ?? 0);
+  const rows = Effect.sync(() => stdout.rows ?? 0);
+  const readInput = Effect.gen(function* () {
+    const queue = yield* Queue.make();
+    const handleKeypress = (s, k) => {
+      const userInput = {
+        input: Option.fromUndefinedOr(s),
+        key: {
+          name: k.name ?? "",
+          ctrl: !!k.ctrl,
+          meta: !!k.meta,
+          shift: !!k.shift
+        }
+      };
+      Queue.offerUnsafe(queue, userInput);
+      if (shouldQuit(userInput)) {
+        Queue.endUnsafe(queue);
+      }
+    };
+    const keepAlive = setInterval(() => {
+    }, 2147483647);
+    const handleEnd = () => {
+      clearInterval(keepAlive);
+      Queue.endUnsafe(queue);
+    };
+    yield* Effect.addFinalizer(() => Effect.sync(() => {
+      clearInterval(keepAlive);
+      stdin.off("keypress", handleKeypress);
+      stdin.off("end", handleEnd);
+    }));
+    stdin.on("keypress", handleKeypress);
+    if (inputEnded) {
+      handleEnd();
+    } else {
+      yield* RcRef.get(rlRef);
+      stdin.once("end", handleEnd);
+    }
+    return queue;
+  });
+  const readLine = Effect.suspend(() => Queue.poll(lines).pipe(Effect.flatMap(Option.match({
+    onNone: () => Effect.scoped(Effect.andThen(RcRef.get(rlRef), Queue.take(lines))),
+    onSome: Effect.succeed
+  })), Effect.mapError(() => new Terminal.QuitError({}))));
+  const display = (prompt) => Effect.uninterruptible(Effect.callback((resume) => {
+    stdout.write(prompt, (err) => Predicate.isNullish(err) ? resume(Effect.void) : resume(Effect.fail(badArgument({
+      module: "Terminal",
+      method: "display",
+      description: "Failed to write prompt to stdout",
+      cause: err
+    }))));
+  }));
+  return Terminal.make({
+    columns,
+    rows,
+    readInput,
+    readLine,
+    display
+  });
+});
+var layer = /* @__PURE__ */ Layer.effect(Terminal.Terminal, /* @__PURE__ */ make4(defaultShouldQuit));
+function defaultShouldQuit(input) {
+  const key = input.key;
+  return key.name === "escape" || key.ctrl && (key.name === "c" || key.name === "d");
+}
+
+export {
+  make4 as make,
+  layer,
+  NodeTerminal_exports
+};

package/dist/vendor/chunk-GITB76ZP.js

@@ -0,0 +1,22 @@
+import {
+  layer,
+  make
+} from "./chunk-FIPFWLCV.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/NodeTerminal.js
+var NodeTerminal_exports = {};
+__export(NodeTerminal_exports, {
+  layer: () => layer2,
+  make: () => make2
+});
+var make2 = make;
+var layer2 = layer;
+
+export {
+  make2 as make,
+  layer2 as layer,
+  NodeTerminal_exports
+};

package/dist/vendor/chunk-GMORYZG4.js

@@ -0,0 +1,62 @@
+import {
+  NetSocket,
+  NodeWS,
+  fromDuplex,
+  layerNet,
+  layerTls,
+  makeNet,
+  makeNetChannel,
+  makeTls,
+  makeTlsChannel
+} from "./chunk-Q7YXUH7M.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/NodeSocket.js
+var NodeSocket_exports = {};
+__export(NodeSocket_exports, {
+  NetSocket: () => NetSocket,
+  NodeWS: () => NodeWS,
+  fromDuplex: () => fromDuplex,
+  layerNet: () => layerNet,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  layerWebSocketConstructor: () => layerWebSocketConstructor,
+  layerWebSocketConstructorWS: () => layerWebSocketConstructorWS,
+  makeNet: () => makeNet,
+  makeNetChannel: () => makeNetChannel,
+  makeTls: () => makeTls,
+  makeTlsChannel: () => makeTlsChannel
+});
+import { flow } from "effect/Function";
+import * as Layer from "effect/Layer";
+import * as Socket from "effect/socket/Socket";
+var makeWebSocketWS = (url, options) => {
+  if (options === void 0 || typeof options === "string" || Array.isArray(options)) {
+    return new NodeWS.WebSocket(url, options);
+  }
+  return new NodeWS.WebSocket(url, options.protocols, {
+    headers: options.headers
+  });
+};
+var layerWebSocketConstructor = /* @__PURE__ */ Layer.sync(Socket.WebSocketConstructor)(() => {
+  if ("WebSocket" in globalThis) {
+    return (url, options) => {
+      if (options === void 0 || typeof options === "string" || Array.isArray(options)) {
+        return new globalThis.WebSocket(url, options);
+      }
+      return makeWebSocketWS(url, options);
+    };
+  }
+  return makeWebSocketWS;
+});
+var layerWebSocketConstructorWS = /* @__PURE__ */ Layer.succeed(Socket.WebSocketConstructor)(makeWebSocketWS);
+var layerWebSocket = /* @__PURE__ */ flow(Socket.makeWebSocket, /* @__PURE__ */ Layer.effect(Socket.Socket), /* @__PURE__ */ Layer.provide(layerWebSocketConstructor));
+
+export {
+  layerWebSocketConstructor,
+  layerWebSocketConstructorWS,
+  layerWebSocket,
+  NodeSocket_exports
+};

package/dist/vendor/chunk-HXGVOKHF.js

@@ -0,0 +1,22 @@
+import {
+  layer,
+  make
+} from "./chunk-FIPFWLCV.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/BunTerminal.js
+var BunTerminal_exports = {};
+__export(BunTerminal_exports, {
+  layer: () => layer2,
+  make: () => make2
+});
+var make2 = make;
+var layer2 = layer;
+
+export {
+  make2 as make,
+  layer2 as layer,
+  BunTerminal_exports
+};