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

package/dist/vendor/chunk-KANNAI65.js

@@ -0,0 +1,62 @@
+import {
+  layer as layer2
+} from "./chunk-6KYVM2ZC.js";
+import {
+  layerWebSocketConstructor
+} from "./chunk-GMORYZG4.js";
+import {
+  layerK8sHttpClient
+} from "./chunk-2AP6TO77.js";
+import {
+  layerUndici
+} from "./chunk-V577GRCI.js";
+import {
+  layer
+} from "./chunk-ZJEHEPDQ.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/NodeClusterHttp.js
+var NodeClusterHttp_exports = {};
+__export(NodeClusterHttp_exports, {
+  layer: () => layer5,
+  layerHttpServer: () => layerHttpServer,
+  layerK8sHttpClient: () => layerK8sHttpClient
+});
+import * as HttpRunner from "effect/cluster/HttpRunner";
+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 SqlMessageStorage from "effect/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import { createServer } from "node:http";
+var layer5 = (options) => {
+  const layer6 = options.clientOnly ? options.transport === "http" ? Layer.provide(HttpRunner.layerHttpClientOnly, layerUndici) : Layer.provide(HttpRunner.layerWebsocketClientOnly, layerWebSocketConstructor) : options.transport === "http" ? Layer.provide(HttpRunner.layerHttp, [layerHttpServer, layerUndici]) : Layer.provide(HttpRunner.layerWebsocket, [layerHttpServer, layerWebSocketConstructor]);
+  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(options.transport === "http" ? HttpRunner.layerClientProtocolHttpDefault.pipe(Layer.provide(layerUndici)) : HttpRunner.layerClientProtocolWebsocketDefault.pipe(Layer.provide(layerWebSocketConstructor))));
+  return layer6.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 layerHttpServer = /* @__PURE__ */ Effect.gen(function* () {
+  const config = yield* ShardingConfig.ShardingConfig;
+  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress);
+  if (Option.isNone(listenAddress)) {
+    return yield* Effect.die("NodeClusterHttp.layerHttpServer: ShardingConfig.runnerAddress is None");
+  }
+  return layer2(createServer, listenAddress.value);
+}).pipe(Layer.unwrap);
+
+export {
+  layer5 as layer,
+  layerHttpServer,
+  NodeClusterHttp_exports
+};

package/dist/vendor/chunk-KEMBVIRS.js

@@ -0,0 +1,128 @@
+import {
+  layer
+} from "./chunk-WNS3OER2.js";
+import {
+  algorithms,
+  compressTransform,
+  make
+} from "./chunk-PBM2HJOX.js";
+import {
+  pipeThroughDuplex
+} 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/NodeHttpPlatform.js
+var NodeHttpPlatform_exports = {};
+__export(NodeHttpPlatform_exports, {
+  layer: () => layer3,
+  make: () => make3
+});
+import * as Effect from "effect/Effect";
+import { pipe } from "effect/Function";
+import * as EtagImpl from "effect/http/Etag";
+import * as Headers from "effect/http/Headers";
+import * as HttpBody from "effect/http/HttpBody";
+import * as Platform from "effect/http/HttpPlatform";
+import * as ServerResponse from "effect/http/HttpServerResponse";
+import * as Mime from "effect/http/Mime";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as Fs from "node:fs";
+import { pipeline, Readable } from "node:stream";
+var lazyReadable = (evaluate, onDestroy) => {
+  let source;
+  return new Readable({
+    read() {
+      if (source === void 0) {
+        try {
+          source = evaluate();
+        } catch (cause) {
+          this.destroy(cause instanceof Error ? cause : new Error(String(cause)));
+          return;
+        }
+        source.on("data", (chunk) => {
+          if (!this.push(chunk)) source.pause();
+        });
+        source.once("end", () => this.push(null));
+        source.once("error", (cause) => this.destroy(cause));
+        source.once("close", () => {
+          if (!source.readableEnded) this.destroy(new Error("Response stream closed prematurely"));
+        });
+      }
+      source.resume();
+    },
+    destroy(error, callback) {
+      source?.destroy(error ?? void 0);
+      onDestroy?.();
+      callback(error);
+    }
+  });
+};
+var compressedBody = (response, body) => ServerResponse.removeHeader(ServerResponse.setBody(response, body), "content-length");
+var compression = /* @__PURE__ */ make({
+  algorithms,
+  compressResponse(response, algorithm, options) {
+    const body = response.body;
+    switch (body._tag) {
+      case "Stream": {
+        return Effect.succeed(compressedBody(response, HttpBody.stream(pipeThroughDuplex(body.stream, {
+          evaluate: () => compressTransform(algorithm, options)
+        }), response.headers["content-type"] ?? body.contentType)));
+      }
+      case "Raw": {
+        let readable = body.body instanceof Readable ? body.body : void 0;
+        const compressed = lazyReadable(() => {
+          const transform = compressTransform(algorithm, options);
+          readable ??= Readable.fromWeb(new Response(body.body).body);
+          return pipeline(readable, transform, (cause) => {
+            if (cause) compressed.destroy(cause);
+          });
+        }, () => readable?.destroy());
+        return Effect.succeed(compressedBody(response, HttpBody.raw(compressed, {
+          contentType: response.headers["content-type"] ?? body.contentType
+        })));
+      }
+      default: {
+        return Effect.succeed(response);
+      }
+    }
+  }
+});
+var make3 = /* @__PURE__ */ Platform.make({
+  platform: "node",
+  compression,
+  fileResponse(path, status, statusText, headers, start, end, contentLength) {
+    const stream2 = lazyReadable(() => contentLength === BigInt(0) ? Readable.from([]) : Fs.createReadStream(path, {
+      start,
+      end: end === void 0 ? void 0 : end - 1
+    }));
+    return ServerResponse.raw(stream2, {
+      headers: {
+        ...headers,
+        "content-type": headers["content-type"] ?? Option.getOrElse(Mime.getType(path), () => "application/octet-stream"),
+        "content-length": contentLength.toString()
+      },
+      status,
+      statusText
+    });
+  },
+  fileWebResponse(file, status, statusText, headers, _options) {
+    return ServerResponse.raw(lazyReadable(() => Readable.fromWeb(file.stream())), {
+      headers: Headers.merge(headers, Headers.fromRecordUnsafe({
+        "content-type": headers["content-type"] ?? (file.type === "" ? Option.getOrElse(Mime.getType(file.name), () => "application/octet-stream") : file.type),
+        "content-length": file.size.toString()
+      })),
+      status,
+      statusText
+    });
+  }
+});
+var layer3 = /* @__PURE__ */ pipe(/* @__PURE__ */ Layer.effect(Platform.HttpPlatform)(make3), /* @__PURE__ */ Layer.provide(layer), /* @__PURE__ */ Layer.provide(EtagImpl.layer));
+
+export {
+  make3 as make,
+  layer3 as layer,
+  NodeHttpPlatform_exports
+};

package/dist/vendor/chunk-M2QOSF47.js

@@ -0,0 +1,53 @@
+import {
+  layer
+} from "./chunk-UXIG7ALP.js";
+import {
+  makeNet
+} from "./chunk-Q7YXUH7M.js";
+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/NodeClusterSocket.js
+var NodeClusterSocket_exports = {};
+__export(NodeClusterSocket_exports, {
+  layerClientProtocol: () => layerClientProtocol,
+  layerSocketServer: () => layerSocketServer
+});
+import * as Runners from "effect/cluster/Runners";
+import * as ShardingConfig from "effect/cluster/ShardingConfig";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as RpcClient from "effect/rpc/RpcClient";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+import { Socket } from "effect/socket/Socket";
+var layerClientProtocol = /* @__PURE__ */ Layer.effect(Runners.RpcClientProtocol)(/* @__PURE__ */ Effect.gen(function* () {
+  const serialization = yield* RpcSerialization.RpcSerialization;
+  return {
+    codecFor: serialization.codecFor,
+    make: Effect.fnUntraced(function* (address) {
+      const socket = yield* makeNet({
+        openTimeout: 1e3,
+        timeout: 5500,
+        host: address.host,
+        port: address.port
+      });
+      return yield* RpcClient.makeProtocolSocket().pipe(Effect.provideService(Socket, socket), Effect.provideService(RpcSerialization.RpcSerialization, serialization));
+    }, Effect.orDie)
+  };
+}));
+var layerSocketServer = /* @__PURE__ */ Effect.gen(function* () {
+  const config = yield* ShardingConfig.ShardingConfig;
+  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress);
+  if (Option.isNone(listenAddress)) {
+    return yield* Effect.die("layerSocketServer: ShardingConfig.runnerListenAddress is None");
+  }
+  return layer(listenAddress.value);
+}).pipe(Layer.unwrap);
+
+export {
+  layerClientProtocol,
+  layerSocketServer,
+  NodeClusterSocket_exports
+};

package/dist/vendor/chunk-MLKGABMK.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/dist/vendor/chunk-NGGMPIWR.js

@@ -0,0 +1,65 @@
+import {
+  layerWebSocketConstructor
+} from "./chunk-RX5TKFP7.js";
+import {
+  layer as layer3
+} from "./chunk-BVV46N3V.js";
+import {
+  layerK8sHttpClient
+} from "./chunk-EIO7BKW3.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/BunClusterHttp.js
+var BunClusterHttp_exports = {};
+__export(BunClusterHttp_exports, {
+  layer: () => layer7,
+  layerHttpServer: () => layerHttpServer,
+  layerK8sHttpClient: () => layerK8sHttpClient
+});
+import * as HttpRunner from "effect/cluster/HttpRunner";
+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 SqlMessageStorage from "effect/cluster/SqlMessageStorage";
+import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage";
+import * as Effect from "effect/Effect";
+import * as FetchHttpClient from "effect/http/FetchHttpClient";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
+var layerHttpServer = /* @__PURE__ */ Effect.gen(function* () {
+  const config = yield* ShardingConfig.ShardingConfig;
+  const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress);
+  if (Option.isNone(listenAddress)) {
+    return yield* Effect.die("BunClusterHttp.layerHttpServer: ShardingConfig.runnerAddress is None");
+  }
+  return layer3({
+    hostname: listenAddress.value.host,
+    port: listenAddress.value.port
+  });
+}).pipe(Layer.unwrap);
+var layer7 = (options) => {
+  const layer8 = options.clientOnly ? options.transport === "http" ? Layer.provide(HttpRunner.layerHttpClientOnly, FetchHttpClient.layer) : Layer.provide(HttpRunner.layerWebsocketClientOnly, layerWebSocketConstructor) : options.transport === "http" ? Layer.provide(HttpRunner.layerHttp, [layerHttpServer, FetchHttpClient.layer]) : Layer.provide(HttpRunner.layerWebsocket, [layerHttpServer, layerWebSocketConstructor]);
+  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(options.transport === "http" ? HttpRunner.layerClientProtocolHttpDefault.pipe(Layer.provide(FetchHttpClient.layer)) : HttpRunner.layerClientProtocolWebsocketDefault.pipe(Layer.provide(layerWebSocketConstructor))));
+  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
+  })));
+};
+
+export {
+  layerHttpServer,
+  layer7 as layer,
+  BunClusterHttp_exports
+};

package/dist/vendor/chunk-NNTJGFLB.js

@@ -0,0 +1,21 @@
+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/NodeHttpServerRequest.js
+var NodeHttpServerRequest_exports = {};
+__export(NodeHttpServerRequest_exports, {
+  toIncomingMessage: () => toIncomingMessage,
+  toServerResponse: () => toServerResponse
+});
+var toIncomingMessage = (self) => self.source;
+var toServerResponse = (self) => {
+  const res = self.response;
+  return typeof res === "function" ? res() : res;
+};
+
+export {
+  toIncomingMessage,
+  toServerResponse,
+  NodeHttpServerRequest_exports
+};

package/dist/vendor/chunk-NU53DHQR.js

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

package/dist/vendor/chunk-OAY4MA3I.js

@@ -0,0 +1,28 @@
+import {
+  IncomingMessage,
+  layer,
+  layerTls,
+  layerWebSocket,
+  make,
+  makeTls,
+  makeWebSocket
+} from "./chunk-UXIG7ALP.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/BunSocketServer.js
+var BunSocketServer_exports = {};
+__export(BunSocketServer_exports, {
+  IncomingMessage: () => IncomingMessage,
+  layer: () => layer,
+  layerTls: () => layerTls,
+  layerWebSocket: () => layerWebSocket,
+  make: () => make,
+  makeTls: () => makeTls,
+  makeWebSocket: () => makeWebSocket
+});
+
+export {
+  BunSocketServer_exports
+};

package/dist/vendor/chunk-OV2KKGBA.js

@@ -0,0 +1,16 @@
+import {
+  layer
+} from "./chunk-AW6WQVI7.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/NodeAddressResolver.js
+var NodeAddressResolver_exports = {};
+__export(NodeAddressResolver_exports, {
+  layer: () => layer
+});
+
+export {
+  NodeAddressResolver_exports
+};

package/dist/vendor/chunk-PBM2HJOX.js

@@ -0,0 +1,118 @@
+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/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/http/HttpBody";
+import * as Response from "effect/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-Q5UCOQNO.js

@@ -0,0 +1,70 @@
+import {
+  fromDuplex,
+  fromReadable,
+  fromReadableChannel,
+  pipeThroughDuplex,
+  pipeThroughSimple,
+  toArrayBuffer,
+  toReadable,
+  toReadableNever,
+  toString,
+  toUint8Array
+} from "./chunk-T5WDTZCE.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/BunStream.js
+var BunStream_exports = {};
+__export(BunStream_exports, {
+  fromDuplex: () => fromDuplex,
+  fromReadable: () => fromReadable,
+  fromReadableChannel: () => fromReadableChannel,
+  fromReadableStream: () => fromReadableStream,
+  pipeThroughDuplex: () => pipeThroughDuplex,
+  pipeThroughSimple: () => pipeThroughSimple,
+  toArrayBuffer: () => toArrayBuffer,
+  toReadable: () => toReadable,
+  toReadableNever: () => toReadableNever,
+  toString: () => toString,
+  toUint8Array: () => toUint8Array
+});
+import * as Arr from "effect/Array";
+import * as Cause from "effect/Cause";
+import * as Channel from "effect/Channel";
+import * as Effect from "effect/Effect";
+import { constVoid } from "effect/Function";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+var fromReadableStream = (options) => Stream.fromChannel(Channel.fromTransform(Effect.fnUntraced(function* (_, scope) {
+  const reader = options.evaluate().getReader();
+  yield* Scope.addFinalizer(scope, options.releaseLockOnEnd ? Effect.sync(() => reader.releaseLock()) : Effect.promise(() => reader.cancel().catch(constVoid)));
+  function readMany() {
+    let result;
+    try {
+      result = reader.readMany();
+    } catch (error) {
+      return Effect.fail(options.onError(error));
+    }
+    if ("then" in result) {
+      return Effect.callback((resume) => {
+        result.then((_2) => resume(handleResult(_2)), (e) => resume(Effect.fail(options.onError(e))));
+      });
+    }
+    return handleResult(result);
+  }
+  function handleResult(result) {
+    if (result.done) {
+      return Cause.done();
+    } else if (!Arr.isReadonlyArrayNonEmpty(result.value)) {
+      return readMany();
+    }
+    return Effect.succeed(result.value);
+  }
+  return Effect.suspend(readMany);
+})));
+
+export {
+  fromReadableStream,
+  BunStream_exports
+};