@replit/river 0.10.13 → 0.11.0

package/dist/chunk-GKPT5YQE.js

@@ -0,0 +1,90 @@
+import {
+  Connection
+} from "./chunk-LQXPKF3A.js";
+
+// transport/transforms/messageFraming.ts
+import { Transform } from "node:stream";
+var Uint32LengthPrefixFraming = class extends Transform {
+  receivedBuffer;
+  maxBufferSizeBytes;
+  constructor({
+    preAllocatedBufferSize,
+    maxBufferSizeBytes,
+    ...options
+  }) {
+    super(options);
+    this.maxBufferSizeBytes = maxBufferSizeBytes;
+    this.receivedBuffer = Buffer.alloc(preAllocatedBufferSize);
+  }
+  _transform(chunk, _encoding, cb) {
+    if (this.receivedBuffer.byteLength + chunk.byteLength > this.maxBufferSizeBytes) {
+      const err = new Error(
+        `buffer overflow: ${this.receivedBuffer.byteLength}B > ${this.maxBufferSizeBytes}B`
+      );
+      this.emit("error", err);
+      return cb(err);
+    }
+    this.receivedBuffer = Buffer.concat([this.receivedBuffer, chunk]);
+    while (this.receivedBuffer.length > 4) {
+      const claimedMessageLength = this.receivedBuffer.readUInt32BE(0) + 4;
+      if (this.receivedBuffer.length >= claimedMessageLength) {
+        const message = this.receivedBuffer.subarray(4, claimedMessageLength);
+        this.push(message);
+        this.receivedBuffer = this.receivedBuffer.subarray(claimedMessageLength);
+      } else {
+        break;
+      }
+    }
+    cb();
+  }
+  _flush(cb) {
+    if (this.receivedBuffer.length) {
+      this.emit("error", new Error("got incomplete message while flushing"));
+    }
+    this.receivedBuffer = Buffer.alloc(0);
+    cb();
+  }
+  _destroy(error, callback) {
+    this.receivedBuffer = Buffer.alloc(0);
+    super._destroy(error, callback);
+  }
+};
+function createLengthEncodedStream(options) {
+  return new Uint32LengthPrefixFraming({
+    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024,
+    // 16MB
+    preAllocatedBufferSize: options?.preAllocatedBufferSize ?? 16 * 1024
+    // 16KB
+  });
+}
+var MessageFramer = {
+  createFramedStream: createLengthEncodedStream,
+  write: (buf) => {
+    const lengthPrefix = Buffer.alloc(4);
+    lengthPrefix.writeUInt32BE(buf.length, 0);
+    return Buffer.concat([lengthPrefix, buf]);
+  }
+};
+
+// transport/impls/stdio/connection.ts
+var StreamConnection = class extends Connection {
+  output;
+  constructor(transport, connectedTo, output) {
+    super(transport, connectedTo);
+    this.output = output;
+  }
+  send(payload) {
+    if (!this.output.writable) {
+      return false;
+    }
+    return this.output.write(MessageFramer.write(payload));
+  }
+  async close() {
+    this.output.end();
+  }
+};
+
+export {
+  MessageFramer,
+  StreamConnection
+};

package/dist/transport/impls/stdio/stdio.cjs

@@ -73,59 +73,69 @@ var NaiveJsonCodec = {
 // logging/index.ts
 var log;
 
-// transport/transforms/delim.ts
+// transport/transforms/messageFraming.ts
 var import_node_stream = require("stream");
-var DelimiterParser = class extends import_node_stream.Transform {
-  delimiter;
-  buffer;
+var Uint32LengthPrefixFraming = class extends import_node_stream.Transform {
+  receivedBuffer;
   maxBufferSizeBytes;
-  constructor({ delimiter, maxBufferSizeBytes, ...options }) {
+  constructor({
+    preAllocatedBufferSize,
+    maxBufferSizeBytes,
+    ...options
+  }) {
     super(options);
     this.maxBufferSizeBytes = maxBufferSizeBytes;
-    this.delimiter = Buffer.from(delimiter);
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(preAllocatedBufferSize);
   }
-  // tldr; backpressure will be automatically applied for transform streams
-  // but it relies on both the input/output streams connected on either end having
-  // implemented backpressure properly
-  // see: https://nodejs.org/en/guides/backpressuring-in-streams#lifecycle-of-pipe
   _transform(chunk, _encoding, cb) {
-    let data = Buffer.concat([this.buffer, chunk]);
-    let position;
-    while ((position = data.indexOf(this.delimiter)) !== -1) {
-      this.push(data.subarray(0, position));
-      data = data.subarray(position + this.delimiter.length);
-    }
-    if (data.byteLength > this.maxBufferSizeBytes) {
+    if (this.receivedBuffer.byteLength + chunk.byteLength > this.maxBufferSizeBytes) {
       const err = new Error(
-        `buffer overflow: ${data.byteLength}B > ${this.maxBufferSizeBytes}B`
+        `buffer overflow: ${this.receivedBuffer.byteLength}B > ${this.maxBufferSizeBytes}B`
       );
       this.emit("error", err);
       return cb(err);
     }
-    this.buffer = data;
+    this.receivedBuffer = Buffer.concat([this.receivedBuffer, chunk]);
+    while (this.receivedBuffer.length > 4) {
+      const claimedMessageLength = this.receivedBuffer.readUInt32BE(0) + 4;
+      if (this.receivedBuffer.length >= claimedMessageLength) {
+        const message = this.receivedBuffer.subarray(4, claimedMessageLength);
+        this.push(message);
+        this.receivedBuffer = this.receivedBuffer.subarray(claimedMessageLength);
+      } else {
+        break;
+      }
+    }
     cb();
   }
   _flush(cb) {
-    if (this.buffer.length) {
-      this.push(this.buffer);
+    if (this.receivedBuffer.length) {
+      this.emit("error", new Error("got incomplete message while flushing"));
     }
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(0);
     cb();
   }
   _destroy(error, callback) {
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(0);
     super._destroy(error, callback);
   }
 };
-var defaultDelimiter = Buffer.from("\n");
-function createDelimitedStream(options) {
-  return new DelimiterParser({
-    delimiter: options?.delimiter ?? defaultDelimiter,
-    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
+function createLengthEncodedStream(options) {
+  return new Uint32LengthPrefixFraming({
+    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024,
     // 16MB
+    preAllocatedBufferSize: options?.preAllocatedBufferSize ?? 16 * 1024
+    // 16KB
   });
 }
+var MessageFramer = {
+  createFramedStream: createLengthEncodedStream,
+  write: (buf) => {
+    const lengthPrefix = Buffer.alloc(4);
+    lengthPrefix.writeUInt32BE(buf.length, 0);
+    return Buffer.concat([lengthPrefix, buf]);
+  }
+};
 
 // transport/transport.ts
 var import_value = require("@sinclair/typebox/value");
@@ -444,7 +454,7 @@ var StreamConnection = class extends Connection {
     if (!this.output.writable) {
       return false;
     }
-    return this.output.write(Buffer.concat([payload, defaultDelimiter]));
+    return this.output.write(MessageFramer.write(payload));
   }
   async close() {
     this.output.end();
@@ -467,8 +477,8 @@ var StdioTransport = class extends Transport {
   constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
     const options = { ...defaultOptions, ...providedOptions };
     super(options.codec, clientId);
-    const delimStream = createDelimitedStream();
-    this.input = input.pipe(delimStream);
+    const framedMessageStream = MessageFramer.createFramedStream();
+    this.input = input.pipe(framedMessageStream);
     this.output = output;
     let conn = void 0;
     this.input.on("data", (msg) => {
@@ -480,7 +490,7 @@ var StdioTransport = class extends Transport {
       this.handleMsg(parsedMsg);
     });
     const cleanup = () => {
-      delimStream.destroy();
+      framedMessageStream.destroy();
       if (conn) {
         this.onDisconnect(conn);
       }

package/dist/transport/impls/stdio/stdio.js

@@ -1,7 +1,7 @@
 import {
-  StreamConnection,
-  createDelimitedStream
-} from "../../../chunk-3MQETIGZ.js";
+  MessageFramer,
+  StreamConnection
+} from "../../../chunk-GKPT5YQE.js";
 import "../../../chunk-ORAG7IAU.js";
 import {
   NaiveJsonCodec
@@ -30,8 +30,8 @@ var StdioTransport = class extends Transport {
   constructor(clientId, input = process.stdin, output = process.stdout, providedOptions) {
     const options = { ...defaultOptions, ...providedOptions };
     super(options.codec, clientId);
-    const delimStream = createDelimitedStream();
-    this.input = input.pipe(delimStream);
+    const framedMessageStream = MessageFramer.createFramedStream();
+    this.input = input.pipe(framedMessageStream);
     this.output = output;
     let conn = void 0;
     this.input.on("data", (msg) => {
@@ -43,7 +43,7 @@ var StdioTransport = class extends Transport {
       this.handleMsg(parsedMsg);
     });
     const cleanup = () => {
-      delimStream.destroy();
+      framedMessageStream.destroy();
       if (conn) {
         this.onDisconnect(conn);
       }

package/dist/transport/impls/unixsocket/client.cjs

@@ -379,59 +379,69 @@ var NaiveJsonCodec = {
   }
 };
 
-// transport/transforms/delim.ts
+// transport/transforms/messageFraming.ts
 var import_node_stream = require("stream");
-var DelimiterParser = class extends import_node_stream.Transform {
-  delimiter;
-  buffer;
+var Uint32LengthPrefixFraming = class extends import_node_stream.Transform {
+  receivedBuffer;
   maxBufferSizeBytes;
-  constructor({ delimiter, maxBufferSizeBytes, ...options }) {
+  constructor({
+    preAllocatedBufferSize,
+    maxBufferSizeBytes,
+    ...options
+  }) {
     super(options);
     this.maxBufferSizeBytes = maxBufferSizeBytes;
-    this.delimiter = Buffer.from(delimiter);
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(preAllocatedBufferSize);
   }
-  // tldr; backpressure will be automatically applied for transform streams
-  // but it relies on both the input/output streams connected on either end having
-  // implemented backpressure properly
-  // see: https://nodejs.org/en/guides/backpressuring-in-streams#lifecycle-of-pipe
   _transform(chunk, _encoding, cb) {
-    let data = Buffer.concat([this.buffer, chunk]);
-    let position;
-    while ((position = data.indexOf(this.delimiter)) !== -1) {
-      this.push(data.subarray(0, position));
-      data = data.subarray(position + this.delimiter.length);
-    }
-    if (data.byteLength > this.maxBufferSizeBytes) {
+    if (this.receivedBuffer.byteLength + chunk.byteLength > this.maxBufferSizeBytes) {
       const err = new Error(
-        `buffer overflow: ${data.byteLength}B > ${this.maxBufferSizeBytes}B`
+        `buffer overflow: ${this.receivedBuffer.byteLength}B > ${this.maxBufferSizeBytes}B`
       );
       this.emit("error", err);
       return cb(err);
     }
-    this.buffer = data;
+    this.receivedBuffer = Buffer.concat([this.receivedBuffer, chunk]);
+    while (this.receivedBuffer.length > 4) {
+      const claimedMessageLength = this.receivedBuffer.readUInt32BE(0) + 4;
+      if (this.receivedBuffer.length >= claimedMessageLength) {
+        const message = this.receivedBuffer.subarray(4, claimedMessageLength);
+        this.push(message);
+        this.receivedBuffer = this.receivedBuffer.subarray(claimedMessageLength);
+      } else {
+        break;
+      }
+    }
     cb();
   }
   _flush(cb) {
-    if (this.buffer.length) {
-      this.push(this.buffer);
+    if (this.receivedBuffer.length) {
+      this.emit("error", new Error("got incomplete message while flushing"));
     }
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(0);
     cb();
   }
   _destroy(error, callback) {
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(0);
     super._destroy(error, callback);
   }
 };
-var defaultDelimiter = Buffer.from("\n");
-function createDelimitedStream(options) {
-  return new DelimiterParser({
-    delimiter: options?.delimiter ?? defaultDelimiter,
-    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
+function createLengthEncodedStream(options) {
+  return new Uint32LengthPrefixFraming({
+    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024,
     // 16MB
+    preAllocatedBufferSize: options?.preAllocatedBufferSize ?? 16 * 1024
+    // 16KB
   });
 }
+var MessageFramer = {
+  createFramedStream: createLengthEncodedStream,
+  write: (buf) => {
+    const lengthPrefix = Buffer.alloc(4);
+    lengthPrefix.writeUInt32BE(buf.length, 0);
+    return Buffer.concat([lengthPrefix, buf]);
+  }
+};
 
 // transport/impls/unixsocket/client.ts
 var import_node_net = require("net");
@@ -447,7 +457,7 @@ var StreamConnection = class extends Connection {
     if (!this.output.writable) {
       return false;
     }
-    return this.output.write(Buffer.concat([payload, defaultDelimiter]));
+    return this.output.write(MessageFramer.write(payload));
   }
   async close() {
     this.output.end();
@@ -477,15 +487,15 @@ var UnixDomainSocketClientTransport = class extends Transport {
     }
     const sock = (0, import_node_net.createConnection)(this.path);
     const conn = new StreamConnection(this, to, sock);
-    const delimStream = createDelimitedStream();
-    sock.pipe(delimStream).on("data", (data) => {
+    const framedMessageStream = MessageFramer.createFramedStream();
+    sock.pipe(framedMessageStream).on("data", (data) => {
       const parsedMsg = this.parseMsg(data);
       if (parsedMsg) {
         this.handleMsg(parsedMsg);
       }
     });
     const cleanup = () => {
-      delimStream.destroy();
+      framedMessageStream.destroy();
       if (conn) {
         this.onDisconnect(conn);
       }

package/dist/transport/impls/unixsocket/client.js

@@ -1,7 +1,7 @@
 import {
-  StreamConnection,
-  createDelimitedStream
-} from "../../../chunk-3MQETIGZ.js";
+  MessageFramer,
+  StreamConnection
+} from "../../../chunk-GKPT5YQE.js";
 import "../../../chunk-ORAG7IAU.js";
 import "../../../chunk-WVT5QXMZ.js";
 import {
@@ -39,15 +39,15 @@ var UnixDomainSocketClientTransport = class extends Transport {
     }
     const sock = createConnection(this.path);
     const conn = new StreamConnection(this, to, sock);
-    const delimStream = createDelimitedStream();
-    sock.pipe(delimStream).on("data", (data) => {
+    const framedMessageStream = MessageFramer.createFramedStream();
+    sock.pipe(framedMessageStream).on("data", (data) => {
       const parsedMsg = this.parseMsg(data);
       if (parsedMsg) {
         this.handleMsg(parsedMsg);
       }
     });
     const cleanup = () => {
-      delimStream.destroy();
+      framedMessageStream.destroy();
       if (conn) {
         this.onDisconnect(conn);
       }

package/dist/transport/impls/unixsocket/server.cjs

@@ -379,59 +379,69 @@ var NaiveJsonCodec = {
   }
 };
 
-// transport/transforms/delim.ts
+// transport/transforms/messageFraming.ts
 var import_node_stream = require("stream");
-var DelimiterParser = class extends import_node_stream.Transform {
-  delimiter;
-  buffer;
+var Uint32LengthPrefixFraming = class extends import_node_stream.Transform {
+  receivedBuffer;
   maxBufferSizeBytes;
-  constructor({ delimiter, maxBufferSizeBytes, ...options }) {
+  constructor({
+    preAllocatedBufferSize,
+    maxBufferSizeBytes,
+    ...options
+  }) {
     super(options);
     this.maxBufferSizeBytes = maxBufferSizeBytes;
-    this.delimiter = Buffer.from(delimiter);
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(preAllocatedBufferSize);
   }
-  // tldr; backpressure will be automatically applied for transform streams
-  // but it relies on both the input/output streams connected on either end having
-  // implemented backpressure properly
-  // see: https://nodejs.org/en/guides/backpressuring-in-streams#lifecycle-of-pipe
   _transform(chunk, _encoding, cb) {
-    let data = Buffer.concat([this.buffer, chunk]);
-    let position;
-    while ((position = data.indexOf(this.delimiter)) !== -1) {
-      this.push(data.subarray(0, position));
-      data = data.subarray(position + this.delimiter.length);
-    }
-    if (data.byteLength > this.maxBufferSizeBytes) {
+    if (this.receivedBuffer.byteLength + chunk.byteLength > this.maxBufferSizeBytes) {
       const err = new Error(
-        `buffer overflow: ${data.byteLength}B > ${this.maxBufferSizeBytes}B`
+        `buffer overflow: ${this.receivedBuffer.byteLength}B > ${this.maxBufferSizeBytes}B`
       );
       this.emit("error", err);
       return cb(err);
     }
-    this.buffer = data;
+    this.receivedBuffer = Buffer.concat([this.receivedBuffer, chunk]);
+    while (this.receivedBuffer.length > 4) {
+      const claimedMessageLength = this.receivedBuffer.readUInt32BE(0) + 4;
+      if (this.receivedBuffer.length >= claimedMessageLength) {
+        const message = this.receivedBuffer.subarray(4, claimedMessageLength);
+        this.push(message);
+        this.receivedBuffer = this.receivedBuffer.subarray(claimedMessageLength);
+      } else {
+        break;
+      }
+    }
     cb();
   }
   _flush(cb) {
-    if (this.buffer.length) {
-      this.push(this.buffer);
+    if (this.receivedBuffer.length) {
+      this.emit("error", new Error("got incomplete message while flushing"));
     }
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(0);
     cb();
   }
   _destroy(error, callback) {
-    this.buffer = Buffer.alloc(0);
+    this.receivedBuffer = Buffer.alloc(0);
     super._destroy(error, callback);
   }
 };
-var defaultDelimiter = Buffer.from("\n");
-function createDelimitedStream(options) {
-  return new DelimiterParser({
-    delimiter: options?.delimiter ?? defaultDelimiter,
-    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
+function createLengthEncodedStream(options) {
+  return new Uint32LengthPrefixFraming({
+    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024,
     // 16MB
+    preAllocatedBufferSize: options?.preAllocatedBufferSize ?? 16 * 1024
+    // 16KB
   });
 }
+var MessageFramer = {
+  createFramedStream: createLengthEncodedStream,
+  write: (buf) => {
+    const lengthPrefix = Buffer.alloc(4);
+    lengthPrefix.writeUInt32BE(buf.length, 0);
+    return Buffer.concat([lengthPrefix, buf]);
+  }
+};
 
 // transport/impls/stdio/connection.ts
 var StreamConnection = class extends Connection {
@@ -444,7 +454,7 @@ var StreamConnection = class extends Connection {
     if (!this.output.writable) {
       return false;
     }
-    return this.output.write(Buffer.concat([payload, defaultDelimiter]));
+    return this.output.write(MessageFramer.write(payload));
   }
   async close() {
     this.output.end();
@@ -468,8 +478,8 @@ var UnixDomainSocketServerTransport = class extends Transport {
   }
   connectionListener = (sock) => {
     let conn = void 0;
-    const delimStream = createDelimitedStream();
-    sock.pipe(delimStream).on("data", (data) => {
+    const framedMessageStream = MessageFramer.createFramedStream();
+    sock.pipe(framedMessageStream).on("data", (data) => {
       const parsedMsg = this.parseMsg(data);
       if (!parsedMsg) {
         return;
@@ -481,7 +491,7 @@ var UnixDomainSocketServerTransport = class extends Transport {
       this.handleMsg(parsedMsg);
     });
     const cleanup = () => {
-      delimStream.destroy();
+      framedMessageStream.destroy();
       if (conn) {
         this.onDisconnect(conn);
       }

package/dist/transport/impls/unixsocket/server.js

@@ -1,7 +1,7 @@
 import {
-  StreamConnection,
-  createDelimitedStream
-} from "../../../chunk-3MQETIGZ.js";
+  MessageFramer,
+  StreamConnection
+} from "../../../chunk-GKPT5YQE.js";
 import "../../../chunk-ORAG7IAU.js";
 import "../../../chunk-WVT5QXMZ.js";
 import {
@@ -32,8 +32,8 @@ var UnixDomainSocketServerTransport = class extends Transport {
   }
   connectionListener = (sock) => {
     let conn = void 0;
-    const delimStream = createDelimitedStream();
-    sock.pipe(delimStream).on("data", (data) => {
+    const framedMessageStream = MessageFramer.createFramedStream();
+    sock.pipe(framedMessageStream).on("data", (data) => {
       const parsedMsg = this.parseMsg(data);
       if (!parsedMsg) {
         return;
@@ -45,7 +45,7 @@ var UnixDomainSocketServerTransport = class extends Transport {
       this.handleMsg(parsedMsg);
     });
     const cleanup = () => {
-      delimStream.destroy();
+      framedMessageStream.destroy();
       if (conn) {
         this.onDisconnect(conn);
       }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@replit/river",
   "description": "It's like tRPC but... with JSON Schema Support, duplex streaming and support for service multiplexing. Transport agnostic!",
-  "version": "0.10.13",
+  "version": "0.11.0",
   "type": "module",
   "exports": {
     ".": {

package/dist/chunk-3MQETIGZ.js

@@ -1,80 +0,0 @@
-import {
-  Connection
-} from "./chunk-LQXPKF3A.js";
-
-// transport/transforms/delim.ts
-import { Transform } from "node:stream";
-var DelimiterParser = class extends Transform {
-  delimiter;
-  buffer;
-  maxBufferSizeBytes;
-  constructor({ delimiter, maxBufferSizeBytes, ...options }) {
-    super(options);
-    this.maxBufferSizeBytes = maxBufferSizeBytes;
-    this.delimiter = Buffer.from(delimiter);
-    this.buffer = Buffer.alloc(0);
-  }
-  // tldr; backpressure will be automatically applied for transform streams
-  // but it relies on both the input/output streams connected on either end having
-  // implemented backpressure properly
-  // see: https://nodejs.org/en/guides/backpressuring-in-streams#lifecycle-of-pipe
-  _transform(chunk, _encoding, cb) {
-    let data = Buffer.concat([this.buffer, chunk]);
-    let position;
-    while ((position = data.indexOf(this.delimiter)) !== -1) {
-      this.push(data.subarray(0, position));
-      data = data.subarray(position + this.delimiter.length);
-    }
-    if (data.byteLength > this.maxBufferSizeBytes) {
-      const err = new Error(
-        `buffer overflow: ${data.byteLength}B > ${this.maxBufferSizeBytes}B`
-      );
-      this.emit("error", err);
-      return cb(err);
-    }
-    this.buffer = data;
-    cb();
-  }
-  _flush(cb) {
-    if (this.buffer.length) {
-      this.push(this.buffer);
-    }
-    this.buffer = Buffer.alloc(0);
-    cb();
-  }
-  _destroy(error, callback) {
-    this.buffer = Buffer.alloc(0);
-    super._destroy(error, callback);
-  }
-};
-var defaultDelimiter = Buffer.from("\n");
-function createDelimitedStream(options) {
-  return new DelimiterParser({
-    delimiter: options?.delimiter ?? defaultDelimiter,
-    maxBufferSizeBytes: options?.maxBufferSizeBytes ?? 16 * 1024 * 1024
-    // 16MB
-  });
-}
-
-// transport/impls/stdio/connection.ts
-var StreamConnection = class extends Connection {
-  output;
-  constructor(transport, connectedTo, output) {
-    super(transport, connectedTo);
-    this.output = output;
-  }
-  send(payload) {
-    if (!this.output.writable) {
-      return false;
-    }
-    return this.output.write(Buffer.concat([payload, defaultDelimiter]));
-  }
-  async close() {
-    this.output.end();
-  }
-};
-
-export {
-  createDelimitedStream,
-  StreamConnection
-};