@effect/platform-node 0.21.0 → 0.22.1

package/dist/stream-36ca9d0a.esm.js

@@ -0,0 +1,176 @@
+import * as Channel from 'effect/Channel';
+import * as Chunk from 'effect/Chunk';
+import * as Effect from 'effect/Effect';
+import * as Either from 'effect/Either';
+import * as Exit from 'effect/Exit';
+import { dual, pipe } from 'effect/Function';
+import * as Queue from 'effect/Queue';
+import * as Stream from 'effect/Stream';
+import { SystemError } from '@effect/platform/Error';
+
+/** @internal */
+const fromReadable = (evaluate, onError, {
+  chunkSize
+} = {}) => Stream.fromChannel(readChannel(evaluate, onError, chunkSize ? Number(chunkSize) : undefined));
+
+/** @internal */
+const toString = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect.acquireUseRelease(Effect.sync(() => {
+    const stream = options.readable();
+    stream.setEncoding(options.encoding ?? "utf8");
+    return stream;
+  }), stream => Effect.async(resume => {
+    let string = "";
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect.succeed(string));
+    });
+    stream.on("data", chunk => {
+      string += chunk;
+      bytes += Buffer.byteLength(chunk);
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect.sync(() => {
+    stream.removeAllListeners();
+    if (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const toUint8Array = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect.acquireUseRelease(Effect.sync(options.readable), stream => Effect.async(resume => {
+    let buffer = Buffer.alloc(0);
+    let bytes = 0;
+    stream.once("error", err => {
+      resume(Effect.fail(options.onFailure(err)));
+    });
+    stream.once("end", () => {
+      resume(Effect.succeed(buffer));
+    });
+    stream.on("data", chunk => {
+      buffer = Buffer.concat([buffer, chunk]);
+      bytes += chunk.length;
+      if (maxBytesNumber && bytes > maxBytesNumber) {
+        resume(Effect.fail(options.onFailure(new Error("maxBytes exceeded"))));
+      }
+    });
+  }), stream => Effect.sync(() => {
+    stream.removeAllListeners();
+    if (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const fromDuplex = (evaluate, onError, options = {}) => Channel.acquireUseRelease(Effect.tap(Effect.zip(Effect.sync(evaluate), Queue.unbounded()), ([duplex, queue]) => readableOffer(duplex, queue, onError)), ([duplex, queue]) => Channel.embedInput(readableTake(duplex, queue, options.chunkSize ? Number(options.chunkSize) : undefined), writeInput(duplex, queue, onError, options)), ([duplex, queue]) => Effect.zipRight(Effect.sync(() => {
+  duplex.removeAllListeners();
+  if (!duplex.closed) {
+    duplex.destroy();
+  }
+}), Queue.shutdown(queue)));
+
+/** @internal */
+const pipeThroughDuplex = /*#__PURE__*/dual(args => Stream.StreamTypeId in args[0], (self, duplex, onError, options) => Stream.pipeThroughChannelOrFail(self, fromDuplex(duplex, onError, options)));
+
+/** @internal */
+const pipeThroughSimple = /*#__PURE__*/dual(2, (self, duplex) => Stream.pipeThroughChannelOrFail(self, fromDuplex(duplex, error => SystemError({
+  module: "Stream",
+  method: "pipeThroughSimple",
+  pathOrDescriptor: "",
+  reason: "Unknown",
+  message: String(error)
+}))));
+const readChannel = (evaluate, onError, chunkSize) => Channel.acquireUseRelease(Effect.tap(Effect.zip(Effect.sync(evaluate), Queue.unbounded()), ([readable, queue]) => readableOffer(readable, queue, onError)), ([readable, queue]) => readableTake(readable, queue, chunkSize), ([readable, queue]) => Effect.zipRight(Effect.sync(() => {
+  readable.removeAllListeners();
+  if (!readable.closed) {
+    readable.destroy();
+  }
+}), Queue.shutdown(queue)));
+const writeInput = (writable, queue, onError, {
+  encoding,
+  endOnDone = true
+} = {}) => {
+  const write = writeEffect(writable, onError, encoding);
+  const close = endOnDone ? Effect.async(resume => {
+    if (writable.closed) {
+      resume(Effect.unit);
+    } else {
+      writable.end(() => resume(Effect.unit));
+    }
+  }) : Effect.unit;
+  return {
+    awaitRead: () => Effect.unit,
+    emit: chunk => Effect.catchAllCause(write(chunk), cause => Queue.offer(queue, Either.left(Exit.failCause(cause)))),
+    error: cause => Effect.zipRight(close, Queue.offer(queue, Either.left(Exit.failCause(cause)))),
+    done: _ => close
+  };
+};
+
+/** @internal */
+const writeEffect = (writable, onError, encoding) => chunk => Effect.async(resume => {
+  const iterator = chunk[Symbol.iterator]();
+  function loop() {
+    const item = iterator.next();
+    if (item.done) {
+      resume(Effect.unit);
+    } else if (encoding) {
+      writable.write(item.value, encoding, onDone);
+    } else {
+      writable.write(item.value, onDone);
+    }
+  }
+  function onDone(err) {
+    if (err) {
+      resume(Effect.fail(onError(err)));
+    } else {
+      loop();
+    }
+  }
+  loop();
+});
+const readableOffer = (readable, queue, onError) => Effect.sync(() => {
+  readable.on("readable", () => {
+    const size = queue.unsafeSize();
+    if (size._tag === "Some" && size.value <= 0) {
+      queue.unsafeOffer(Either.right(void 0));
+    }
+  });
+  readable.on("error", err => {
+    queue.unsafeOffer(Either.left(Exit.fail(onError(err))));
+  });
+  readable.on("end", () => {
+    queue.unsafeOffer(Either.left(Exit.unit));
+  });
+  if (readable.readable) {
+    queue.unsafeOffer(Either.right(void 0));
+  }
+});
+const readableTake = (readable, queue, chunkSize) => {
+  const read = readChunkChannel(readable, chunkSize);
+  const loop = pipe(Channel.fromEffect(Queue.take(queue)), Channel.flatMap(Either.match({
+    onLeft: Channel.fromEffect,
+    onRight: _ => Channel.flatMap(read, () => loop)
+  })));
+  return loop;
+};
+const readChunkChannel = (readable, chunkSize) => Channel.flatMap(Channel.sync(() => {
+  const arr = [];
+  let chunk = readable.read(chunkSize);
+  while (chunk !== null) {
+    arr.push(chunk);
+    chunk = readable.read(chunkSize);
+  }
+  return Chunk.unsafeFromArray(arr);
+}), Channel.write);
+
+export { fromDuplex as a, pipeThroughSimple as b, toUint8Array as c, fromReadable as f, pipeThroughDuplex as p, toString as t, writeEffect as w };

package/dist/stream-c01737c4.cjs.prod.js

@@ -0,0 +1,210 @@
+'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 = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
+    const stream = options.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 (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const toUint8Array = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(options.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 (!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, queue, onError, 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 (!readable.closed) {
+    readable.destroy();
+  }
+}), Queue__namespace.shutdown(queue)));
+const writeInput = (writable, queue, onError, {
+  encoding,
+  endOnDone = true
+} = {}) => {
+  const write = writeEffect(writable, onError, encoding);
+  const close = endOnDone ? Effect__namespace.async(resume => {
+    if (writable.closed) {
+      resume(Effect__namespace.unit);
+    } else {
+      writable.end(() => resume(Effect__namespace.unit));
+    }
+  }) : Effect__namespace.unit;
+  return {
+    awaitRead: () => Effect__namespace.unit,
+    emit: chunk => Effect__namespace.catchAllCause(write(chunk), cause => Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause)))),
+    error: cause => Effect__namespace.zipRight(close, Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause)))),
+    done: _ => close
+  };
+};
+
+/** @internal */
+const writeEffect = (writable, onError, encoding) => chunk => Effect__namespace.async(resume => {
+  const iterator = chunk[Symbol.iterator]();
+  function loop() {
+    const item = iterator.next();
+    if (item.done) {
+      resume(Effect__namespace.unit);
+    } else if (encoding) {
+      writable.write(item.value, encoding, onDone);
+    } else {
+      writable.write(item.value, onDone);
+    }
+  }
+  function onDone(err) {
+    if (err) {
+      resume(Effect__namespace.fail(onError(err)));
+    } else {
+      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.writeEffect = writeEffect;

package/dist/stream-c0c7bc20.cjs.dev.js

@@ -0,0 +1,210 @@
+'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 = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(() => {
+    const stream = options.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 (!stream.closed) {
+      stream.destroy();
+    }
+  }));
+};
+
+/** @internal */
+const toUint8Array = options => {
+  const maxBytesNumber = options.maxBytes ? Number(options.maxBytes) : undefined;
+  return Effect__namespace.acquireUseRelease(Effect__namespace.sync(options.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 (!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, queue, onError, 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 (!readable.closed) {
+    readable.destroy();
+  }
+}), Queue__namespace.shutdown(queue)));
+const writeInput = (writable, queue, onError, {
+  encoding,
+  endOnDone = true
+} = {}) => {
+  const write = writeEffect(writable, onError, encoding);
+  const close = endOnDone ? Effect__namespace.async(resume => {
+    if (writable.closed) {
+      resume(Effect__namespace.unit);
+    } else {
+      writable.end(() => resume(Effect__namespace.unit));
+    }
+  }) : Effect__namespace.unit;
+  return {
+    awaitRead: () => Effect__namespace.unit,
+    emit: chunk => Effect__namespace.catchAllCause(write(chunk), cause => Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause)))),
+    error: cause => Effect__namespace.zipRight(close, Queue__namespace.offer(queue, Either__namespace.left(Exit__namespace.failCause(cause)))),
+    done: _ => close
+  };
+};
+
+/** @internal */
+const writeEffect = (writable, onError, encoding) => chunk => Effect__namespace.async(resume => {
+  const iterator = chunk[Symbol.iterator]();
+  function loop() {
+    const item = iterator.next();
+    if (item.done) {
+      resume(Effect__namespace.unit);
+    } else if (encoding) {
+      writable.write(item.value, encoding, onDone);
+    } else {
+      writable.write(item.value, onDone);
+    }
+  }
+  function onDone(err) {
+    if (err) {
+      resume(Effect__namespace.fail(onError(err)));
+    } else {
+      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.writeEffect = writeEffect;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@effect/platform-node",
-  "version": "0.21.0",
+  "version": "0.22.1",
   "description": "Unified interfaces for common platform-specific services",
   "main": "dist/effect-platform-node.cjs.js",
   "module": "dist/effect-platform-node.esm.js",
@@ -33,18 +33,18 @@
   "license": "MIT",
   "sideEffects": false,
   "devDependencies": {
-    "@effect/schema": "^0.41.0",
+    "@effect/schema": "^0.43.0",
     "@types/busboy": "^1.5.1",
     "@types/mime": "^3.0.2",
-    "effect": "2.0.0-next.46"
+    "effect": "2.0.0-next.48"
   },
   "peerDependencies": {
-    "effect": "^2.0.0-next.46"
+    "effect": "2.0.0-next.48"
   },
   "dependencies": {
     "busboy": "^1.6.0",
     "mime": "^3.0.0",
-    "@effect/platform": "^0.20.0"
+    "@effect/platform": "^0.21.0"
   },
   "files": [
     "src",

package/src/Sink.ts

@@ -6,15 +6,7 @@ import type { LazyArg } from "effect/Function"
 import type { Sink } from "effect/Sink"
 import type { Writable } from "stream"
 import * as internal from "./internal/sink"
-
-/**
- * @category model
- * @since 1.0.0
- */
-export interface FromWritableOptions {
-  readonly endOnClose?: boolean
-  readonly encoding?: BufferEncoding
-}
+import type { FromWritableOptions } from "./Stream"
 
 /**
  * @category constructor