@effect/platform-node 0.22.0 → 0.23.0

package/dist/{incomingMessage-f56be93e.cjs.prod.js → incomingMessage-4526b216.cjs.prod.js}

@@ -51,8 +51,7 @@ class IncomingMessageImpl {
     if (this.textEffect) {
       return this.textEffect;
     }
-    this.textEffect = Effect__namespace.runSync(Effect__namespace.cached(Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toString({
-      readable: () => this.source,
+    this.textEffect = Effect__namespace.runSync(Effect__namespace.cached(Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toString(() => this.source, {
       onFailure: this.onError,
       maxBytes: Option__namespace.getOrUndefined(maxBodySize)
     }))));
@@ -74,8 +73,7 @@ class IncomingMessageImpl {
     return Stream_dist_effectPlatformNodeStream.fromReadable(() => this.source, this.onError);
   }
   get arrayBuffer() {
-    return Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toUint8Array({
-      readable: () => this.source,
+    return Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toUint8Array(() => this.source, {
       onFailure: this.onError,
       maxBytes: Option__namespace.getOrUndefined(maxBodySize)
     }));

package/dist/{incomingMessage-11c9bea6.esm.js → incomingMessage-a56317f6.esm.js}

@@ -24,8 +24,7 @@ class IncomingMessageImpl {
     if (this.textEffect) {
       return this.textEffect;
     }
-    this.textEffect = Effect.runSync(Effect.cached(Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => toString({
-      readable: () => this.source,
+    this.textEffect = Effect.runSync(Effect.cached(Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => toString(() => this.source, {
       onFailure: this.onError,
       maxBytes: Option.getOrUndefined(maxBodySize)
     }))));
@@ -47,8 +46,7 @@ class IncomingMessageImpl {
     return fromReadable(() => this.source, this.onError);
   }
   get arrayBuffer() {
-    return Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => toUint8Array({
-      readable: () => this.source,
+    return Effect.flatMap(FiberRef.get(IncomingMessage.maxBodySize), maxBodySize => toUint8Array(() => this.source, {
       onFailure: this.onError,
       maxBytes: Option.getOrUndefined(maxBodySize)
     }));

package/dist/{incomingMessage-86bcf94d.cjs.dev.js → incomingMessage-ac1817d4.cjs.dev.js}

@@ -51,8 +51,7 @@ class IncomingMessageImpl {
     if (this.textEffect) {
       return this.textEffect;
     }
-    this.textEffect = Effect__namespace.runSync(Effect__namespace.cached(Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toString({
-      readable: () => this.source,
+    this.textEffect = Effect__namespace.runSync(Effect__namespace.cached(Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toString(() => this.source, {
       onFailure: this.onError,
       maxBytes: Option__namespace.getOrUndefined(maxBodySize)
     }))));
@@ -74,8 +73,7 @@ class IncomingMessageImpl {
     return Stream_dist_effectPlatformNodeStream.fromReadable(() => this.source, this.onError);
   }
   get arrayBuffer() {
-    return Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toUint8Array({
-      readable: () => this.source,
+    return Effect__namespace.flatMap(FiberRef__namespace.get(IncomingMessage__namespace.maxBodySize), maxBodySize => Stream_dist_effectPlatformNodeStream.toUint8Array(() => this.source, {
       onFailure: this.onError,
       maxBytes: Option__namespace.getOrUndefined(maxBodySize)
     }));

package/dist/sink-3a150604.cjs.dev.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var Channel = require('effect/Channel');
+var Deferred = require('effect/Deferred');
+var Effect = require('effect/Effect');
+var Sink = require('effect/Sink');
+var stream = require('./stream-8bbecb96.cjs.dev.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Channel__namespace = /*#__PURE__*/_interopNamespace(Channel);
+var Deferred__namespace = /*#__PURE__*/_interopNamespace(Deferred);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Sink__namespace = /*#__PURE__*/_interopNamespace(Sink);
+
+/** @internal */
+const fromWritable = (evaluate, onError, options = {}) => Sink__namespace.suspend(() => Sink__namespace.fromChannel(writeChannel(evaluate(), onError, options)));
+const writeChannel = (writable, onError, options = {}) => Channel__namespace.flatMap(Deferred__namespace.make(), deferred => {
+  const input = stream.writeInput(writable, _ => Deferred__namespace.failCause(deferred, _), options, Deferred__namespace.complete(deferred, Effect__namespace.unit));
+  return Channel__namespace.embedInput(writableOutput(writable, deferred, onError), input);
+});
+const writableOutput = (writable, deferred, onError) => Effect__namespace.raceFirst(Effect__namespace.async(resume => {
+  function handleError(err) {
+    resume(Effect__namespace.fail(onError(err)));
+  }
+  writable.on("error", handleError);
+  return Effect__namespace.sync(() => {
+    writable.off("error", handleError);
+  });
+}), Deferred__namespace.await(deferred));
+
+exports.fromWritable = fromWritable;

package/dist/sink-570c8582.cjs.prod.js

@@ -0,0 +1,48 @@
+'use strict';
+
+var Channel = require('effect/Channel');
+var Deferred = require('effect/Deferred');
+var Effect = require('effect/Effect');
+var Sink = require('effect/Sink');
+var stream = require('./stream-1667e8bf.cjs.prod.js');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Channel__namespace = /*#__PURE__*/_interopNamespace(Channel);
+var Deferred__namespace = /*#__PURE__*/_interopNamespace(Deferred);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Sink__namespace = /*#__PURE__*/_interopNamespace(Sink);
+
+/** @internal */
+const fromWritable = (evaluate, onError, options = {}) => Sink__namespace.suspend(() => Sink__namespace.fromChannel(writeChannel(evaluate(), onError, options)));
+const writeChannel = (writable, onError, options = {}) => Channel__namespace.flatMap(Deferred__namespace.make(), deferred => {
+  const input = stream.writeInput(writable, _ => Deferred__namespace.failCause(deferred, _), options, Deferred__namespace.complete(deferred, Effect__namespace.unit));
+  return Channel__namespace.embedInput(writableOutput(writable, deferred, onError), input);
+});
+const writableOutput = (writable, deferred, onError) => Effect__namespace.raceFirst(Effect__namespace.async(resume => {
+  function handleError(err) {
+    resume(Effect__namespace.fail(onError(err)));
+  }
+  writable.on("error", handleError);
+  return Effect__namespace.sync(() => {
+    writable.off("error", handleError);
+  });
+}), Deferred__namespace.await(deferred));
+
+exports.fromWritable = fromWritable;

package/dist/sink-5dfcc09e.esm.js

@@ -0,0 +1,23 @@
+import * as Channel from 'effect/Channel';
+import * as Deferred from 'effect/Deferred';
+import * as Effect from 'effect/Effect';
+import * as Sink from 'effect/Sink';
+import { w as writeInput } from './stream-faaffb40.esm.js';
+
+/** @internal */
+const fromWritable = (evaluate, onError, options = {}) => Sink.suspend(() => Sink.fromChannel(writeChannel(evaluate(), onError, options)));
+const writeChannel = (writable, onError, options = {}) => Channel.flatMap(Deferred.make(), deferred => {
+  const input = writeInput(writable, _ => Deferred.failCause(deferred, _), options, Deferred.complete(deferred, Effect.unit));
+  return Channel.embedInput(writableOutput(writable, deferred, onError), input);
+});
+const writableOutput = (writable, deferred, onError) => Effect.raceFirst(Effect.async(resume => {
+  function handleError(err) {
+    resume(Effect.fail(onError(err)));
+  }
+  writable.on("error", handleError);
+  return Effect.sync(() => {
+    writable.off("error", handleError);
+  });
+}), Deferred.await(deferred));
+
+export { fromWritable as f };

package/dist/stream-1667e8bf.cjs.prod.js

@@ -0,0 +1,209 @@
+'use strict';
+
+var Channel = require('effect/Channel');
+var Chunk = require('effect/Chunk');
+var Effect = require('effect/Effect');
+var Either = require('effect/Either');
+var Exit = require('effect/Exit');
+var Function = require('effect/Function');
+var Queue = require('effect/Queue');
+var Stream = require('effect/Stream');
+var Error$1 = require('@effect/platform/Error');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Channel__namespace = /*#__PURE__*/_interopNamespace(Channel);
+var Chunk__namespace = /*#__PURE__*/_interopNamespace(Chunk);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Either__namespace = /*#__PURE__*/_interopNamespace(Either);
+var Exit__namespace = /*#__PURE__*/_interopNamespace(Exit);
+var Queue__namespace = /*#__PURE__*/_interopNamespace(Queue);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const fromReadable = (evaluate, onError, {
+  chunkSize
+} = {}) => Stream__namespace.fromChannel(readChannel(evaluate, onError, chunkSize ? Number(chunkSize) : undefined));
+
+/** @internal */
+const toString = (readable, options) => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
+    const stream = readable();
+    stream.setEncoding(options.encoding ?? "utf8");
+    return stream;
+  }), stream => Effect__namespace.async(resume => {
+    let string = "";
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(string));
+    });
+    stream.on("data", chunk => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if ("closed" in stream && !stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const toUint8Array = (readable, options) => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(readable), stream => Effect__namespace.async(resume => {
+    let buffer = Buffer.alloc(0);
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(buffer));
+    });
+    stream.on("data", chunk => {
+      buffer = Buffer.concat([buffer, chunk]);
+      bytes += chunk.length;
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if ("closed" in stream && !stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const fromDuplex = (evaluate, onError, options = {}) => Channel__namespace.acquireUseRelease(Effect__namespace.tap(Effect__namespace.zip(Effect__namespace.sync(evaluate), Queue__namespace.unbounded()), ([duplex, queue]) => readableOffer(duplex, queue, onError)), ([duplex, queue]) => Channel__namespace.embedInput(readableTake(duplex, queue, options.chunkSize ? Number(options.chunkSize) : undefined), writeInput(duplex, cause => Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause))), options)), ([duplex, queue]) => Effect__namespace.zipRight(Effect__namespace.sync(() => {
+  duplex.removeAllListeners();
+  if (!duplex.closed) {
+    duplex.destroy();
+  }
+}), Queue__namespace.shutdown(queue)));
+
+/** @internal */
+const pipeThroughDuplex = /*#__PURE__*/Function.dual(args => Stream__namespace.StreamTypeId in args[0], (self, duplex, onError, options) => Stream__namespace.pipeThroughChannelOrFail(self, fromDuplex(duplex, onError, options)));
+
+/** @internal */
+const pipeThroughSimple = /*#__PURE__*/Function.dual(2, (self, duplex) => Stream__namespace.pipeThroughChannelOrFail(self, fromDuplex(duplex, error => Error$1.SystemError({
+  module: "Stream",
+  method: "pipeThroughSimple",
+  pathOrDescriptor: "",
+  reason: "Unknown",
+  message: String(error)
+}))));
+const readChannel = (evaluate, onError, chunkSize) => Channel__namespace.acquireUseRelease(Effect__namespace.tap(Effect__namespace.zip(Effect__namespace.sync(evaluate), Queue__namespace.unbounded()), ([readable, queue]) => readableOffer(readable, queue, onError)), ([readable, queue]) => readableTake(readable, queue, chunkSize), ([readable, queue]) => Effect__namespace.zipRight(Effect__namespace.sync(() => {
+  readable.removeAllListeners();
+  if ("closed" in readable && !readable.closed) {
+    readable.destroy();
+  }
+}), Queue__namespace.shutdown(queue)));
+
+/** @internal */
+const writeInput = (writable, onFailure, {
+  encoding,
+  endOnDone = true
+}, onDone = Effect__namespace.unit) => {
+  const write = writeEffect(writable, encoding);
+  const close = endOnDone ? Effect__namespace.async(resume => {
+    if ("closed" in writable && writable.closed) {
+      resume(Effect__namespace.unit);
+    } else {
+      writable.once("finish", () => resume(Effect__namespace.unit));
+      writable.end();
+    }
+  }) : Effect__namespace.unit;
+  return {
+    awaitRead: () => Effect__namespace.unit,
+    emit: write,
+    error: cause => Effect__namespace.zipRight(close, onFailure(cause)),
+    done: _ => Effect__namespace.zipRight(close, onDone)
+  };
+};
+
+/** @internal */
+const writeEffect = (writable, encoding) => chunk => chunk.length === 0 ? Effect__namespace.unit : Effect__namespace.async(resume => {
+  const iterator = chunk[Symbol.iterator]();
+  let next = iterator.next();
+  function loop() {
+    const item = next;
+    next = iterator.next();
+    const success = writable.write(item.value, encoding);
+    if (next.done) {
+      resume(Effect__namespace.unit);
+    } else if (success) {
+      loop();
+    } else {
+      writable.once("drain", loop);
+    }
+  }
+  loop();
+});
+const readableOffer = (readable, queue, onError) => Effect__namespace.sync(() => {
+  readable.on("readable", () => {
+    const size = queue.unsafeSize();
+    if (size._tag === "Some" && size.value <= 0) {
+      queue.unsafeOffer(Either__namespace.right(void 0));
+    }
+  });
+  readable.on("error", err => {
+    queue.unsafeOffer(Either__namespace.left(Exit__namespace.fail(onError(err))));
+  });
+  readable.on("end", () => {
+    queue.unsafeOffer(Either__namespace.left(Exit__namespace.unit));
+  });
+  if (readable.readable) {
+    queue.unsafeOffer(Either__namespace.right(void 0));
+  }
+});
+const readableTake = (readable, queue, chunkSize) => {
+  const read = readChunkChannel(readable, chunkSize);
+  const loop = Function.pipe(Channel__namespace.fromEffect(Queue__namespace.take(queue)), Channel__namespace.flatMap(Either__namespace.match({
+    onLeft: Channel__namespace.fromEffect,
+    onRight: _ => Channel__namespace.flatMap(read, () => loop)
+  })));
+  return loop;
+};
+const readChunkChannel = (readable, chunkSize) => Channel__namespace.flatMap(Channel__namespace.sync(() => {
+  const arr = [];
+  let chunk = readable.read(chunkSize);
+  while (chunk !== null) {
+    arr.push(chunk);
+    chunk = readable.read(chunkSize);
+  }
+  return Chunk__namespace.unsafeFromArray(arr);
+}), Channel__namespace.write);
+
+exports.fromDuplex = fromDuplex;
+exports.fromReadable = fromReadable;
+exports.pipeThroughDuplex = pipeThroughDuplex;
+exports.pipeThroughSimple = pipeThroughSimple;
+exports.toString = toString;
+exports.toUint8Array = toUint8Array;
+exports.writeInput = writeInput;

package/dist/stream-8bbecb96.cjs.dev.js

@@ -0,0 +1,209 @@
+'use strict';
+
+var Channel = require('effect/Channel');
+var Chunk = require('effect/Chunk');
+var Effect = require('effect/Effect');
+var Either = require('effect/Either');
+var Exit = require('effect/Exit');
+var Function = require('effect/Function');
+var Queue = require('effect/Queue');
+var Stream = require('effect/Stream');
+var Error$1 = require('@effect/platform/Error');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n["default"] = e;
+  return Object.freeze(n);
+}
+
+var Channel__namespace = /*#__PURE__*/_interopNamespace(Channel);
+var Chunk__namespace = /*#__PURE__*/_interopNamespace(Chunk);
+var Effect__namespace = /*#__PURE__*/_interopNamespace(Effect);
+var Either__namespace = /*#__PURE__*/_interopNamespace(Either);
+var Exit__namespace = /*#__PURE__*/_interopNamespace(Exit);
+var Queue__namespace = /*#__PURE__*/_interopNamespace(Queue);
+var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
+
+/** @internal */
+const fromReadable = (evaluate, onError, {
+  chunkSize
+} = {}) => Stream__namespace.fromChannel(readChannel(evaluate, onError, chunkSize ? Number(chunkSize) : undefined));
+
+/** @internal */
+const toString = (readable, options) => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
+    const stream = readable();
+    stream.setEncoding(options.encoding ?? "utf8");
+    return stream;
+  }), stream => Effect__namespace.async(resume => {
+    let string = "";
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(string));
+    });
+    stream.on("data", chunk => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if ("closed" in stream && !stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const toUint8Array = (readable, options) => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(readable), stream => Effect__namespace.async(resume => {
+    let buffer = Buffer.alloc(0);
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect__namespace.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect__namespace.succeed(buffer));
+    });
+    stream.on("data", chunk => {
+      buffer = Buffer.concat([buffer, chunk]);
+      bytes += chunk.length;
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect__namespace.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect__namespace.sync(() => {
+    stream.removeAllListeners();
+    if ("closed" in stream && !stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const fromDuplex = (evaluate, onError, options = {}) => Channel__namespace.acquireUseRelease(Effect__namespace.tap(Effect__namespace.zip(Effect__namespace.sync(evaluate), Queue__namespace.unbounded()), ([duplex, queue]) => readableOffer(duplex, queue, onError)), ([duplex, queue]) => Channel__namespace.embedInput(readableTake(duplex, queue, options.chunkSize ? Number(options.chunkSize) : undefined), writeInput(duplex, cause => Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause))), options)), ([duplex, queue]) => Effect__namespace.zipRight(Effect__namespace.sync(() => {
+  duplex.removeAllListeners();
+  if (!duplex.closed) {
+    duplex.destroy();
+  }
+}), Queue__namespace.shutdown(queue)));
+
+/** @internal */
+const pipeThroughDuplex = /*#__PURE__*/Function.dual(args => Stream__namespace.StreamTypeId in args[0], (self, duplex, onError, options) => Stream__namespace.pipeThroughChannelOrFail(self, fromDuplex(duplex, onError, options)));
+
+/** @internal */
+const pipeThroughSimple = /*#__PURE__*/Function.dual(2, (self, duplex) => Stream__namespace.pipeThroughChannelOrFail(self, fromDuplex(duplex, error => Error$1.SystemError({
+  module: "Stream",
+  method: "pipeThroughSimple",
+  pathOrDescriptor: "",
+  reason: "Unknown",
+  message: String(error)
+}))));
+const readChannel = (evaluate, onError, chunkSize) => Channel__namespace.acquireUseRelease(Effect__namespace.tap(Effect__namespace.zip(Effect__namespace.sync(evaluate), Queue__namespace.unbounded()), ([readable, queue]) => readableOffer(readable, queue, onError)), ([readable, queue]) => readableTake(readable, queue, chunkSize), ([readable, queue]) => Effect__namespace.zipRight(Effect__namespace.sync(() => {
+  readable.removeAllListeners();
+  if ("closed" in readable && !readable.closed) {
+    readable.destroy();
+  }
+}), Queue__namespace.shutdown(queue)));
+
+/** @internal */
+const writeInput = (writable, onFailure, {
+  encoding,
+  endOnDone = true
+}, onDone = Effect__namespace.unit) => {
+  const write = writeEffect(writable, encoding);
+  const close = endOnDone ? Effect__namespace.async(resume => {
+    if ("closed" in writable && writable.closed) {
+      resume(Effect__namespace.unit);
+    } else {
+      writable.once("finish", () => resume(Effect__namespace.unit));
+      writable.end();
+    }
+  }) : Effect__namespace.unit;
+  return {
+    awaitRead: () => Effect__namespace.unit,
+    emit: write,
+    error: cause => Effect__namespace.zipRight(close, onFailure(cause)),
+    done: _ => Effect__namespace.zipRight(close, onDone)
+  };
+};
+
+/** @internal */
+const writeEffect = (writable, encoding) => chunk => chunk.length === 0 ? Effect__namespace.unit : Effect__namespace.async(resume => {
+  const iterator = chunk[Symbol.iterator]();
+  let next = iterator.next();
+  function loop() {
+    const item = next;
+    next = iterator.next();
+    const success = writable.write(item.value, encoding);
+    if (next.done) {
+      resume(Effect__namespace.unit);
+    } else if (success) {
+      loop();
+    } else {
+      writable.once("drain", loop);
+    }
+  }
+  loop();
+});
+const readableOffer = (readable, queue, onError) => Effect__namespace.sync(() => {
+  readable.on("readable", () => {
+    const size = queue.unsafeSize();
+    if (size._tag === "Some" && size.value <= 0) {
+      queue.unsafeOffer(Either__namespace.right(void 0));
+    }
+  });
+  readable.on("error", err => {
+    queue.unsafeOffer(Either__namespace.left(Exit__namespace.fail(onError(err))));
+  });
+  readable.on("end", () => {
+    queue.unsafeOffer(Either__namespace.left(Exit__namespace.unit));
+  });
+  if (readable.readable) {
+    queue.unsafeOffer(Either__namespace.right(void 0));
+  }
+});
+const readableTake = (readable, queue, chunkSize) => {
+  const read = readChunkChannel(readable, chunkSize);
+  const loop = Function.pipe(Channel__namespace.fromEffect(Queue__namespace.take(queue)), Channel__namespace.flatMap(Either__namespace.match({
+    onLeft: Channel__namespace.fromEffect,
+    onRight: _ => Channel__namespace.flatMap(read, () => loop)
+  })));
+  return loop;
+};
+const readChunkChannel = (readable, chunkSize) => Channel__namespace.flatMap(Channel__namespace.sync(() => {
+  const arr = [];
+  let chunk = readable.read(chunkSize);
+  while (chunk !== null) {
+    arr.push(chunk);
+    chunk = readable.read(chunkSize);
+  }
+  return Chunk__namespace.unsafeFromArray(arr);
+}), Channel__namespace.write);
+
+exports.fromDuplex = fromDuplex;
+exports.fromReadable = fromReadable;
+exports.pipeThroughDuplex = pipeThroughDuplex;
+exports.pipeThroughSimple = pipeThroughSimple;
+exports.toString = toString;
+exports.toUint8Array = toUint8Array;
+exports.writeInput = writeInput;