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

package/dist/vendor/chunk-2KZ2IFIZ.js

@@ -0,0 +1,71 @@
+import {
+  layer
+} from "./chunk-VZBDV3TV.js";
+import {
+  Dispatcher,
+  layerUndiciNoDispatcher,
+  makeDispatcher
+} from "./chunk-KOZMM5PZ.js";
+import {
+  layer as layer2
+} from "./chunk-M32LDTW7.js";
+import {
+  layerClientProtocol,
+  layerSocketServer
+} from "./chunk-Y35ZAO5U.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/NodeClusterSocket.js
+var NodeClusterSocket_exports = {};
+__export(NodeClusterSocket_exports, {
+  layer: () => layer7,
+  layerClientProtocol: () => layerClientProtocol,
+  layerDispatcherK8s: () => layerDispatcherK8s,
+  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 RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+var layer7 = (options) => {
+  const layer8 = 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(layerK8sHttpClient)) : RunnerHealth.layerPing.pipe(Layer.provide(Runners.layerRpc), Layer.provide(layerClientProtocol));
+  return layer8.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 layerDispatcherK8s = /* @__PURE__ */ Layer.effect(Dispatcher)(Effect.gen(function* () {
+  const fs = yield* FileSystem.FileSystem;
+  const caCertOption = yield* fs.readFileString("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(Effect.option);
+  if (caCertOption._tag === "Some") {
+    const Undici = yield* Effect.promise(() => import("./node/Undici.js"));
+    return yield* Effect.acquireRelease(Effect.sync(() => new Undici.Agent({
+      connect: {
+        ca: caCertOption.value
+      }
+    })), (agent) => Effect.promise(() => agent.destroy()));
+  }
+  return yield* makeDispatcher;
+})).pipe(/* @__PURE__ */ Layer.provide(layer2));
+var layerK8sHttpClient = /* @__PURE__ */ K8sHttpClient.layer.pipe(/* @__PURE__ */ Layer.provide(/* @__PURE__ */ Layer.fresh(layerUndiciNoDispatcher)), /* @__PURE__ */ Layer.provide(layerDispatcherK8s), /* @__PURE__ */ Layer.provide(layer2));
+
+export {
+  layer7 as layer,
+  layerDispatcherK8s,
+  layerK8sHttpClient,
+  NodeClusterSocket_exports
+};

package/dist/vendor/chunk-2Y7WC4KU.js

@@ -0,0 +1,109 @@
+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/NodeMultipartParser.js
+var NodeMultipartParser_exports = {};
+__export(NodeMultipartParser_exports, {
+  FileStream: () => FileStream,
+  MultipartStream: () => MultipartStream,
+  make: () => make
+});
+import { make as makeParser } from "effect/unstable/http/MultipartParser";
+import { Duplex, Readable } from "node:stream";
+var MultipartStream = class extends Duplex {
+  _parser;
+  _canWrite = true;
+  _writeCallback;
+  constructor(config) {
+    super({
+      readableObjectMode: true
+    });
+    let currentError;
+    let currentFile;
+    this._parser = makeParser({
+      ...config,
+      onField: (info, value) => {
+        if (currentError !== void 0) return;
+        const field = {
+          _tag: "Field",
+          info,
+          value
+        };
+        this.push(field);
+        this.emit("field", field);
+      },
+      onFile: (info) => {
+        if (currentError !== void 0) return (_) => {
+        };
+        const file = new FileStream(info, this);
+        currentFile = file;
+        this.push(file);
+        this.emit("file", file);
+        return (chunk) => {
+          if (currentError !== void 0) return;
+          this._canWrite = file.push(chunk);
+          if (chunk === null && !this._canWrite) {
+            currentFile = void 0;
+            this._resume();
+          }
+        };
+      },
+      onError: (error) => {
+        this.emit("error", error);
+        currentFile?.emit("error", error);
+        currentError = error;
+      },
+      onDone: () => {
+        this.push(null);
+      }
+    });
+  }
+  _resume() {
+    this._canWrite = true;
+    if (this._writeCallback !== void 0) {
+      const callback = this._writeCallback;
+      this._writeCallback = void 0;
+      callback();
+    }
+  }
+  _read(_size) {
+  }
+  _write(chunk, encoding, callback) {
+    this._parser.write(chunk instanceof Uint8Array ? chunk : Buffer.from(chunk, encoding));
+    if (this._canWrite) {
+      callback();
+    } else {
+      this._writeCallback = callback;
+    }
+  }
+  _final(callback) {
+    this._parser.end();
+    callback();
+  }
+};
+var make = (config) => new MultipartStream(config);
+var FileStream = class extends Readable {
+  _tag = "File";
+  filename;
+  info;
+  _parent;
+  constructor(info, parent) {
+    super();
+    this.info = info;
+    this._parent = parent;
+    this.filename = info.filename;
+  }
+  _read(_size) {
+    if (this._parent._canWrite === false) {
+      this._parent._resume();
+    }
+  }
+};
+
+export {
+  MultipartStream,
+  make,
+  FileStream,
+  NodeMultipartParser_exports
+};

package/dist/vendor/chunk-3GR5VZ2M.js

@@ -0,0 +1,118 @@
+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/NodeHttpCompression.js
+var NodeHttpCompression_exports = {};
+__export(NodeHttpCompression_exports, {
+  algorithms: () => algorithms,
+  compressTransform: () => compressTransform,
+  compressTransformWeb: () => compressTransformWeb,
+  make: () => make
+});
+import * as Effect from "effect/Effect";
+import * as HttpBody from "effect/unstable/http/HttpBody";
+import * as Response from "effect/unstable/http/HttpServerResponse";
+import { Readable } from "node:stream";
+import * as Zlib from "node:zlib";
+var algorithms = /* @__PURE__ */ new Set(typeof Zlib.zstdCompress === "function" ? ["gzip", "deflate", "br", "zstd"] : ["gzip", "deflate", "br"]);
+var brotliParams = (level, sizeHint) => {
+  const params = {};
+  if (level !== void 0) {
+    params[Zlib.constants.BROTLI_PARAM_QUALITY] = level;
+  }
+  if (sizeHint !== void 0) {
+    params[Zlib.constants.BROTLI_PARAM_SIZE_HINT] = sizeHint;
+  }
+  return {
+    params
+  };
+};
+var zstdParams = (level) => level === void 0 || level === 3 ? void 0 : {
+  params: {
+    [Zlib.constants.ZSTD_c_compressionLevel]: level
+  }
+};
+var compress = (data, algorithm, options) => Effect.callback((resume) => {
+  const complete = (error, result) => resume(error === null ? Effect.succeed(result) : Effect.die(error));
+  switch (algorithm) {
+    case "gzip": {
+      Zlib.gzip(data, {
+        level: options?.level
+      }, complete);
+      break;
+    }
+    case "deflate": {
+      Zlib.deflate(data, {
+        level: options?.level
+      }, complete);
+      break;
+    }
+    case "br": {
+      Zlib.brotliCompress(data, brotliParams(options?.level, data.byteLength), complete);
+      break;
+    }
+    case "zstd": {
+      const params = zstdParams(options?.level);
+      if (params === void 0) {
+        Zlib.zstdCompress(data, complete);
+      } else {
+        Zlib.zstdCompress(data, params, complete);
+      }
+      break;
+    }
+  }
+});
+var make = (fallback) => ({
+  algorithms: fallback.algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body;
+    if (body._tag !== "Uint8Array") {
+      return fallback.compressResponse(response, algorithm, options);
+    }
+    return Effect.map(compress(body.body, algorithm, options), (result) => Response.setHeader(Response.setBody(response, HttpBody.uint8Array(result, response.headers["content-type"] ?? body.contentType)), "content-length", result.byteLength.toString()));
+  }
+});
+var compressTransform = (algorithm, options) => {
+  switch (algorithm) {
+    case "gzip": {
+      return Zlib.createGzip({
+        level: options?.level,
+        flush: Zlib.constants.Z_SYNC_FLUSH
+      });
+    }
+    case "deflate": {
+      return Zlib.createDeflate({
+        level: options?.level,
+        flush: Zlib.constants.Z_SYNC_FLUSH
+      });
+    }
+    case "br": {
+      return Zlib.createBrotliCompress({
+        ...brotliParams(options?.level),
+        flush: Zlib.constants.BROTLI_OPERATION_FLUSH
+      });
+    }
+    case "zstd": {
+      return Zlib.createZstdCompress({
+        ...zstdParams(options?.level),
+        flush: Zlib.constants.ZSTD_e_flush
+      });
+    }
+  }
+};
+var compressTransformWeb = (algorithm, options) => (stream) => {
+  const transform = compressTransform(algorithm, options);
+  const source = Readable.fromWeb(stream);
+  source.on("error", (cause) => transform.destroy(cause));
+  transform.on("close", () => source.destroy());
+  return Readable.toWeb(source.pipe(transform));
+};
+
+export {
+  algorithms,
+  make,
+  compressTransform,
+  compressTransformWeb,
+  NodeHttpCompression_exports
+};

package/dist/vendor/chunk-3QW2PNUY.js

@@ -0,0 +1,7 @@
+// ../../../../node_modules/.pnpm/@effect+platform-bun@4.0.0-rc.115_effect@4.0.0-rc.115/node_modules/@effect/platform-bun/dist/BunHttpClient.js
+var BunHttpClient_exports = {};
+export * from "effect/unstable/http/FetchHttpClient";
+
+export {
+  BunHttpClient_exports
+};

package/dist/vendor/chunk-42QKY6T6.js

@@ -0,0 +1,40 @@
+// ../../../../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/utils.js
+import * as PlatformError from "effect/PlatformError";
+var handleErrnoException = (module, method) => (err, [path]) => {
+  let reason = "Unknown";
+  switch (err.code) {
+    case "ENOENT":
+      reason = "NotFound";
+      break;
+    case "EACCES":
+      reason = "PermissionDenied";
+      break;
+    case "EEXIST":
+      reason = "AlreadyExists";
+      break;
+    case "EISDIR":
+      reason = "BadResource";
+      break;
+    case "ENOTDIR":
+      reason = "BadResource";
+      break;
+    case "EBUSY":
+      reason = "Busy";
+      break;
+    case "ELOOP":
+      reason = "BadResource";
+      break;
+  }
+  return PlatformError.systemError({
+    _tag: reason,
+    module,
+    method,
+    pathOrDescriptor: path,
+    syscall: err.syscall,
+    cause: err
+  });
+};
+
+export {
+  handleErrnoException
+};

package/dist/vendor/chunk-54RLBMTZ.js

@@ -0,0 +1,61 @@
+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/NodePath.js
+var NodePath_exports = {};
+__export(NodePath_exports, {
+  layer: () => layer,
+  layerPosix: () => layerPosix,
+  layerWin32: () => layerWin32
+});
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import { Path, TypeId } from "effect/Path";
+import { BadArgument } from "effect/PlatformError";
+import * as NodePath from "node:path";
+import * as NodeUrl from "node:url";
+var fileUrlOps = (windows) => ({
+  fromFileUrl: (url) => Effect.try({
+    try: () => NodeUrl.fileURLToPath(url, {
+      windows
+    }),
+    catch: (cause) => new BadArgument({
+      module: "Path",
+      method: "fromFileUrl",
+      cause
+    })
+  }),
+  toFileUrl: (path) => Effect.try({
+    try: () => NodeUrl.pathToFileURL(path, {
+      windows
+    }),
+    catch: (cause) => new BadArgument({
+      module: "Path",
+      method: "toFileUrl",
+      cause
+    })
+  })
+});
+var layerPosix = /* @__PURE__ */ Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath.posix,
+  .../* @__PURE__ */ fileUrlOps(false)
+});
+var layerWin32 = /* @__PURE__ */ Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath.win32,
+  .../* @__PURE__ */ fileUrlOps(true)
+});
+var layer = /* @__PURE__ */ Layer.succeed(Path)({
+  [TypeId]: TypeId,
+  ...NodePath,
+  .../* @__PURE__ */ fileUrlOps(void 0)
+});
+
+export {
+  layerPosix,
+  layerWin32,
+  layer,
+  NodePath_exports
+};

package/dist/vendor/chunk-5U3MC37H.js

@@ -0,0 +1,63 @@
+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/BunWorker.js
+var BunWorker_exports = {};
+__export(BunWorker_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, WorkerUnknownError } from "effect/unstable/workers/WorkerError";
+var layer = (spawn) => Layer.merge(layerPlatform, Layer.succeed(Worker.Spawner)(spawn));
+var layerPlatform = /* @__PURE__ */ Layer.succeed(Worker.WorkerPlatform)(/* @__PURE__ */ Worker.makePlatform()({
+  setup({
+    scope,
+    worker
+  }) {
+    const closeDeferred = Deferred.makeUnsafe();
+    worker.addEventListener("close", () => {
+      Deferred.doneUnsafe(closeDeferred, Exit.void);
+    });
+    return Effect.as(Scope.addFinalizer(scope, Effect.suspend(() => {
+      worker.postMessage([1]);
+      return Deferred.await(closeDeferred);
+    }).pipe(Effect.interruptible, Effect.timeout(5e3), Effect.catchCause(() => Effect.sync(() => worker.terminate())))), worker);
+  },
+  listen({
+    deferred,
+    emit,
+    port,
+    scope
+  }) {
+    function onMessage(event) {
+      emit(event.data);
+    }
+    function onError(event) {
+      Deferred.doneUnsafe(deferred, new WorkerError({
+        reason: new WorkerUnknownError({
+          message: "An error event was emitted",
+          cause: event.error ?? event.message
+        })
+      }));
+    }
+    port.addEventListener("message", onMessage);
+    port.addEventListener("error", onError);
+    return Scope.addFinalizer(scope, Effect.sync(() => {
+      port.removeEventListener("message", onMessage);
+      port.removeEventListener("error", onError);
+    }));
+  }
+}));
+
+export {
+  layer,
+  layerPlatform,
+  BunWorker_exports
+};

package/dist/vendor/chunk-5ZMHBXIK.js

@@ -0,0 +1,55 @@
+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-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/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/unstable/socket/Socket";
+var makeWebSocketWS = (url, options) => new NodeWS.WebSocket(url, options);
+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-64Q2B7BA.js

@@ -0,0 +1,34 @@
+import {
+  layer as layer5
+} from "./chunk-KUUXSID7.js";
+import {
+  layer as layer6
+} from "./chunk-XDKNKFBW.js";
+import {
+  layer as layer4
+} from "./chunk-TFIKFFSC.js";
+import {
+  layer as layer2
+} from "./chunk-VZBDV3TV.js";
+import {
+  layer as layer3
+} from "./chunk-M32LDTW7.js";
+import {
+  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/NodeServices.js
+var NodeServices_exports = {};
+__export(NodeServices_exports, {
+  layer: () => layer7
+});
+import * as Layer from "effect/Layer";
+var layer7 = /* @__PURE__ */ Layer.provideMerge(layer, /* @__PURE__ */ Layer.mergeAll(layer3, layer2, layer4, layer5, layer6));
+
+export {
+  layer7 as layer,
+  NodeServices_exports
+};

package/dist/vendor/chunk-6CRG556Y.js

@@ -0,0 +1,15 @@
+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/BunHttpServerRequest.js
+var BunHttpServerRequest_exports = {};
+__export(BunHttpServerRequest_exports, {
+  toBunServerRequest: () => toBunServerRequest
+});
+var toBunServerRequest = (self) => self.source;
+
+export {
+  toBunServerRequest,
+  BunHttpServerRequest_exports
+};

package/dist/vendor/chunk-6HWHSZL3.js

@@ -0,0 +1,34 @@
+import {
+  layer as layer5
+} from "./chunk-SFHVFMSR.js";
+import {
+  layer as layer6
+} from "./chunk-BBLQEPNJ.js";
+import {
+  layer as layer4
+} from "./chunk-RNBBYWS2.js";
+import {
+  layer
+} from "./chunk-IR7WG7SA.js";
+import {
+  layer as layer2
+} from "./chunk-6TZ7LQAC.js";
+import {
+  layer as layer3
+} 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/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
+};