@replit/river 0.10.1 → 0.10.3

package/dist/{builder-3c4485f0.d.ts → builder-87111051.d.ts}

@@ -1,5 +1,5 @@
 import * as _sinclair_typebox from '@sinclair/typebox';
-import { TObject, TLiteralString, TString, TSchema, TUnion, TNever, Static } from '@sinclair/typebox';
+import { TObject, TLiteralString, TUnion, TString, TSchema, TNever, Static } from '@sinclair/typebox';
 import { Pushable } from 'it-pushable';
 
 /**
@@ -33,10 +33,10 @@ type ServiceContextWithState<State extends object | unknown> = ServiceContext &
 };
 
 type RiverErrorSchema = TObject<{
-    code: TLiteralString;
+    code: TLiteralString | TUnion<TLiteralString[]>;
     message: TLiteralString | TString;
 }> | TObject<{
-    code: TLiteralString;
+    code: TLiteralString | TUnion<TLiteralString[]>;
     message: TLiteralString | TString;
     extras: TSchema;
 }>;

package/dist/{chunk-7WJ6YLE5.js → chunk-IYRPZPSQ.js}

@@ -99,8 +99,289 @@ function buildServiceDefs(services) {
   }, {});
 }
 
+// node_modules/p-defer/index.js
+function pDefer() {
+  const deferred = {};
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+  return deferred;
+}
+
+// node_modules/it-pushable/dist/src/fifo.js
+var FixedFIFO = class {
+  buffer;
+  mask;
+  top;
+  btm;
+  next;
+  constructor(hwm) {
+    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
+      throw new Error("Max size for a FixedFIFO should be a power of two");
+    }
+    this.buffer = new Array(hwm);
+    this.mask = hwm - 1;
+    this.top = 0;
+    this.btm = 0;
+    this.next = null;
+  }
+  push(data) {
+    if (this.buffer[this.top] !== void 0) {
+      return false;
+    }
+    this.buffer[this.top] = data;
+    this.top = this.top + 1 & this.mask;
+    return true;
+  }
+  shift() {
+    const last = this.buffer[this.btm];
+    if (last === void 0) {
+      return void 0;
+    }
+    this.buffer[this.btm] = void 0;
+    this.btm = this.btm + 1 & this.mask;
+    return last;
+  }
+  isEmpty() {
+    return this.buffer[this.btm] === void 0;
+  }
+};
+var FIFO = class {
+  size;
+  hwm;
+  head;
+  tail;
+  constructor(options = {}) {
+    this.hwm = options.splitLimit ?? 16;
+    this.head = new FixedFIFO(this.hwm);
+    this.tail = this.head;
+    this.size = 0;
+  }
+  calculateSize(obj) {
+    if (obj?.byteLength != null) {
+      return obj.byteLength;
+    }
+    return 1;
+  }
+  push(val) {
+    if (val?.value != null) {
+      this.size += this.calculateSize(val.value);
+    }
+    if (!this.head.push(val)) {
+      const prev = this.head;
+      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+      this.head.push(val);
+    }
+  }
+  shift() {
+    let val = this.tail.shift();
+    if (val === void 0 && this.tail.next != null) {
+      const next = this.tail.next;
+      this.tail.next = null;
+      this.tail = next;
+      val = this.tail.shift();
+    }
+    if (val?.value != null) {
+      this.size -= this.calculateSize(val.value);
+    }
+    return val;
+  }
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+};
+
+// node_modules/it-pushable/dist/src/index.js
+var AbortError = class extends Error {
+  type;
+  code;
+  constructor(message, code) {
+    super(message ?? "The operation was aborted");
+    this.type = "aborted";
+    this.code = code ?? "ABORT_ERR";
+  }
+};
+function pushable(options = {}) {
+  const getNext = (buffer) => {
+    const next = buffer.shift();
+    if (next == null) {
+      return { done: true };
+    }
+    if (next.error != null) {
+      throw next.error;
+    }
+    return {
+      done: next.done === true,
+      // @ts-expect-error if done is false, value will be present
+      value: next.value
+    };
+  };
+  return _pushable(getNext, options);
+}
+function _pushable(getNext, options) {
+  options = options ?? {};
+  let onEnd = options.onEnd;
+  let buffer = new FIFO();
+  let pushable2;
+  let onNext;
+  let ended;
+  let drain = pDefer();
+  const waitNext = async () => {
+    try {
+      if (!buffer.isEmpty()) {
+        return getNext(buffer);
+      }
+      if (ended) {
+        return { done: true };
+      }
+      return await new Promise((resolve, reject) => {
+        onNext = (next) => {
+          onNext = null;
+          buffer.push(next);
+          try {
+            resolve(getNext(buffer));
+          } catch (err) {
+            reject(err);
+          }
+          return pushable2;
+        };
+      });
+    } finally {
+      if (buffer.isEmpty()) {
+        queueMicrotask(() => {
+          drain.resolve();
+          drain = pDefer();
+        });
+      }
+    }
+  };
+  const bufferNext = (next) => {
+    if (onNext != null) {
+      return onNext(next);
+    }
+    buffer.push(next);
+    return pushable2;
+  };
+  const bufferError = (err) => {
+    buffer = new FIFO();
+    if (onNext != null) {
+      return onNext({ error: err });
+    }
+    buffer.push({ error: err });
+    return pushable2;
+  };
+  const push = (value) => {
+    if (ended) {
+      return pushable2;
+    }
+    if (options?.objectMode !== true && value?.byteLength == null) {
+      throw new Error("objectMode was not true but tried to push non-Uint8Array value");
+    }
+    return bufferNext({ done: false, value });
+  };
+  const end = (err) => {
+    if (ended)
+      return pushable2;
+    ended = true;
+    return err != null ? bufferError(err) : bufferNext({ done: true });
+  };
+  const _return = () => {
+    buffer = new FIFO();
+    end();
+    return { done: true };
+  };
+  const _throw = (err) => {
+    end(err);
+    return { done: true };
+  };
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next: waitNext,
+    return: _return,
+    throw: _throw,
+    push,
+    end,
+    get readableLength() {
+      return buffer.size;
+    },
+    onEmpty: async (options2) => {
+      const signal = options2?.signal;
+      signal?.throwIfAborted();
+      if (buffer.isEmpty()) {
+        return;
+      }
+      let cancel;
+      let listener;
+      if (signal != null) {
+        cancel = new Promise((resolve, reject) => {
+          listener = () => {
+            reject(new AbortError());
+          };
+          signal.addEventListener("abort", listener);
+        });
+      }
+      try {
+        await Promise.race([
+          drain.promise,
+          cancel
+        ]);
+      } finally {
+        if (listener != null && signal != null) {
+          signal?.removeEventListener("abort", listener);
+        }
+      }
+    }
+  };
+  if (onEnd == null) {
+    return pushable2;
+  }
+  const _pushable2 = pushable2;
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      return _pushable2.next();
+    },
+    throw(err) {
+      _pushable2.throw(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    return() {
+      _pushable2.return();
+      if (onEnd != null) {
+        onEnd();
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    push,
+    end(err) {
+      _pushable2.end(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return pushable2;
+    },
+    get readableLength() {
+      return _pushable2.readableLength;
+    },
+    onEmpty: (opts) => {
+      return _pushable2.onEmpty(opts);
+    }
+  };
+  return pushable2;
+}
+
 // router/client.ts
-import { pushable } from "it-pushable";
 import { nanoid } from "nanoid";
 
 // router/result.ts
@@ -411,7 +692,6 @@ function handleUpload(transport, serverId, input, serviceName, procName) {
 }
 
 // router/server.ts
-import { pushable as pushable2 } from "it-pushable";
 import { Value } from "@sinclair/typebox/value";
 var RiverServer = class {
   transport;
@@ -499,8 +779,8 @@ var RiverServer = class {
       return;
     }
     const procedure = service.procedures[message.procedureName];
-    const incoming = pushable2({ objectMode: true });
-    const outgoing = pushable2({ objectMode: true });
+    const incoming = pushable({ objectMode: true });
+    const outgoing = pushable({ objectMode: true });
     const outputHandler = (
       // sending outgoing messages back to client
       (async () => {
@@ -674,6 +954,7 @@ export {
   serializeService,
   ServiceBuilder,
   buildServiceDefs,
+  pushable,
   UNCAUGHT_ERROR,
   RiverUncaughtSchema,
   Ok,

package/dist/router/index.cjs

@@ -121,8 +121,287 @@ function buildServiceDefs(services) {
   }, {});
 }
 
-// router/client.ts
-var import_it_pushable = require("it-pushable");
+// node_modules/p-defer/index.js
+function pDefer() {
+  const deferred = {};
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+  return deferred;
+}
+
+// node_modules/it-pushable/dist/src/fifo.js
+var FixedFIFO = class {
+  buffer;
+  mask;
+  top;
+  btm;
+  next;
+  constructor(hwm) {
+    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
+      throw new Error("Max size for a FixedFIFO should be a power of two");
+    }
+    this.buffer = new Array(hwm);
+    this.mask = hwm - 1;
+    this.top = 0;
+    this.btm = 0;
+    this.next = null;
+  }
+  push(data) {
+    if (this.buffer[this.top] !== void 0) {
+      return false;
+    }
+    this.buffer[this.top] = data;
+    this.top = this.top + 1 & this.mask;
+    return true;
+  }
+  shift() {
+    const last = this.buffer[this.btm];
+    if (last === void 0) {
+      return void 0;
+    }
+    this.buffer[this.btm] = void 0;
+    this.btm = this.btm + 1 & this.mask;
+    return last;
+  }
+  isEmpty() {
+    return this.buffer[this.btm] === void 0;
+  }
+};
+var FIFO = class {
+  size;
+  hwm;
+  head;
+  tail;
+  constructor(options = {}) {
+    this.hwm = options.splitLimit ?? 16;
+    this.head = new FixedFIFO(this.hwm);
+    this.tail = this.head;
+    this.size = 0;
+  }
+  calculateSize(obj) {
+    if (obj?.byteLength != null) {
+      return obj.byteLength;
+    }
+    return 1;
+  }
+  push(val) {
+    if (val?.value != null) {
+      this.size += this.calculateSize(val.value);
+    }
+    if (!this.head.push(val)) {
+      const prev = this.head;
+      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+      this.head.push(val);
+    }
+  }
+  shift() {
+    let val = this.tail.shift();
+    if (val === void 0 && this.tail.next != null) {
+      const next = this.tail.next;
+      this.tail.next = null;
+      this.tail = next;
+      val = this.tail.shift();
+    }
+    if (val?.value != null) {
+      this.size -= this.calculateSize(val.value);
+    }
+    return val;
+  }
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+};
+
+// node_modules/it-pushable/dist/src/index.js
+var AbortError = class extends Error {
+  type;
+  code;
+  constructor(message, code) {
+    super(message ?? "The operation was aborted");
+    this.type = "aborted";
+    this.code = code ?? "ABORT_ERR";
+  }
+};
+function pushable(options = {}) {
+  const getNext = (buffer) => {
+    const next = buffer.shift();
+    if (next == null) {
+      return { done: true };
+    }
+    if (next.error != null) {
+      throw next.error;
+    }
+    return {
+      done: next.done === true,
+      // @ts-expect-error if done is false, value will be present
+      value: next.value
+    };
+  };
+  return _pushable(getNext, options);
+}
+function _pushable(getNext, options) {
+  options = options ?? {};
+  let onEnd = options.onEnd;
+  let buffer = new FIFO();
+  let pushable2;
+  let onNext;
+  let ended;
+  let drain = pDefer();
+  const waitNext = async () => {
+    try {
+      if (!buffer.isEmpty()) {
+        return getNext(buffer);
+      }
+      if (ended) {
+        return { done: true };
+      }
+      return await new Promise((resolve, reject) => {
+        onNext = (next) => {
+          onNext = null;
+          buffer.push(next);
+          try {
+            resolve(getNext(buffer));
+          } catch (err) {
+            reject(err);
+          }
+          return pushable2;
+        };
+      });
+    } finally {
+      if (buffer.isEmpty()) {
+        queueMicrotask(() => {
+          drain.resolve();
+          drain = pDefer();
+        });
+      }
+    }
+  };
+  const bufferNext = (next) => {
+    if (onNext != null) {
+      return onNext(next);
+    }
+    buffer.push(next);
+    return pushable2;
+  };
+  const bufferError = (err) => {
+    buffer = new FIFO();
+    if (onNext != null) {
+      return onNext({ error: err });
+    }
+    buffer.push({ error: err });
+    return pushable2;
+  };
+  const push = (value) => {
+    if (ended) {
+      return pushable2;
+    }
+    if (options?.objectMode !== true && value?.byteLength == null) {
+      throw new Error("objectMode was not true but tried to push non-Uint8Array value");
+    }
+    return bufferNext({ done: false, value });
+  };
+  const end = (err) => {
+    if (ended)
+      return pushable2;
+    ended = true;
+    return err != null ? bufferError(err) : bufferNext({ done: true });
+  };
+  const _return = () => {
+    buffer = new FIFO();
+    end();
+    return { done: true };
+  };
+  const _throw = (err) => {
+    end(err);
+    return { done: true };
+  };
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next: waitNext,
+    return: _return,
+    throw: _throw,
+    push,
+    end,
+    get readableLength() {
+      return buffer.size;
+    },
+    onEmpty: async (options2) => {
+      const signal = options2?.signal;
+      signal?.throwIfAborted();
+      if (buffer.isEmpty()) {
+        return;
+      }
+      let cancel;
+      let listener;
+      if (signal != null) {
+        cancel = new Promise((resolve, reject) => {
+          listener = () => {
+            reject(new AbortError());
+          };
+          signal.addEventListener("abort", listener);
+        });
+      }
+      try {
+        await Promise.race([
+          drain.promise,
+          cancel
+        ]);
+      } finally {
+        if (listener != null && signal != null) {
+          signal?.removeEventListener("abort", listener);
+        }
+      }
+    }
+  };
+  if (onEnd == null) {
+    return pushable2;
+  }
+  const _pushable2 = pushable2;
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      return _pushable2.next();
+    },
+    throw(err) {
+      _pushable2.throw(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    return() {
+      _pushable2.return();
+      if (onEnd != null) {
+        onEnd();
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    push,
+    end(err) {
+      _pushable2.end(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return pushable2;
+    },
+    get readableLength() {
+      return _pushable2.readableLength;
+    },
+    onEmpty: (opts) => {
+      return _pushable2.onEmpty(opts);
+    }
+  };
+  return pushable2;
+}
 
 // transport/message.ts
 var import_typebox2 = require("@sinclair/typebox");
@@ -328,8 +607,8 @@ function handleRpc(transport, serverId, input, serviceName, procName) {
 }
 function handleStream(transport, serverId, init, serviceName, procName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  const inputStream = (0, import_it_pushable.pushable)({ objectMode: true });
-  const outputStream = (0, import_it_pushable.pushable)({ objectMode: true });
+  const inputStream = pushable({ objectMode: true });
+  const outputStream = pushable({ objectMode: true });
   let firstMessage = true;
   if (init) {
     const m = msg(
@@ -402,7 +681,7 @@ function handleSubscribe(transport, serverId, input, serviceName, procName) {
   );
   m.controlFlags |= 2 /* StreamOpenBit */;
   transport.send(m);
-  const outputStream = (0, import_it_pushable.pushable)({ objectMode: true });
+  const outputStream = pushable({ objectMode: true });
   function onMessage(msg2) {
     if (msg2.streamId !== streamId) {
       return;
@@ -437,7 +716,7 @@ function handleSubscribe(transport, serverId, input, serviceName, procName) {
 }
 function handleUpload(transport, serverId, input, serviceName, procName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  const inputStream = (0, import_it_pushable.pushable)({ objectMode: true });
+  const inputStream = pushable({ objectMode: true });
   let firstMessage = true;
   if (input) {
     const m = msg(
@@ -492,9 +771,6 @@ function handleUpload(transport, serverId, input, serviceName, procName) {
   return [inputStream, responsePromise];
 }
 
-// router/server.ts
-var import_it_pushable2 = require("it-pushable");
-
 // logging/index.ts
 var log;
 
@@ -586,8 +862,8 @@ var RiverServer = class {
       return;
     }
     const procedure = service.procedures[message.procedureName];
-    const incoming = (0, import_it_pushable2.pushable)({ objectMode: true });
-    const outgoing = (0, import_it_pushable2.pushable)({ objectMode: true });
+    const incoming = pushable({ objectMode: true });
+    const outgoing = pushable({ objectMode: true });
     const outputHandler = (
       // sending outgoing messages back to client
       (async () => {

package/dist/router/index.d.cts

@@ -1,5 +1,5 @@
-import { A as AnyService, d as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, e as ProcType, f as ProcInput, g as ProcOutput, h as ProcErrors, i as ProcHasInit, j as ProcInit } from '../builder-3c4485f0.js';
-export { E as Err, O as Ok, n as ProcHandler, l as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, m as Service, k as ServiceBuilder, o as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-3c4485f0.js';
+import { A as AnyService, d as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, e as ProcType, f as ProcInput, g as ProcOutput, h as ProcErrors, i as ProcHasInit, j as ProcInit } from '../builder-87111051.js';
+export { E as Err, O as Ok, n as ProcHandler, l as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, m as Service, k as ServiceBuilder, o as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-87111051.js';
 import { Transport, Connection, TransportClientId } from '../transport/index.cjs';
 import { Pushable } from 'it-pushable';
 import { Static } from '@sinclair/typebox';

package/dist/router/index.d.ts

@@ -1,5 +1,5 @@
-import { A as AnyService, d as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, e as ProcType, f as ProcInput, g as ProcOutput, h as ProcErrors, i as ProcHasInit, j as ProcInit } from '../builder-3c4485f0.js';
-export { E as Err, O as Ok, n as ProcHandler, l as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, m as Service, k as ServiceBuilder, o as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-3c4485f0.js';
+import { A as AnyService, d as AnyProcedure, P as PayloadType, b as Result, R as RiverError, S as ServiceContext, e as ProcType, f as ProcInput, g as ProcOutput, h as ProcErrors, i as ProcHasInit, j as ProcInit } from '../builder-87111051.js';
+export { E as Err, O as Ok, n as ProcHandler, l as ProcListing, a as Procedure, p as RiverErrorSchema, c as RiverUncaughtSchema, m as Service, k as ServiceBuilder, o as ServiceContextWithState, U as UNCAUGHT_ERROR, V as ValidProcType, s as serializeService } from '../builder-87111051.js';
 import { Transport, Connection, TransportClientId } from '../transport/index.js';
 import { Pushable } from 'it-pushable';
 import { Static } from '@sinclair/typebox';

package/dist/router/index.js

@@ -8,7 +8,7 @@ import {
   createClient,
   createServer,
   serializeService
-} from "../chunk-7WJ6YLE5.js";
+} from "../chunk-IYRPZPSQ.js";
 import "../chunk-ZE4MX7DF.js";
 import "../chunk-SLUSVGQH.js";
 export {

package/dist/util/testHelpers.cjs

@@ -535,8 +535,287 @@ var WebSocketClientTransport = class extends Transport {
   }
 };
 
-// util/testHelpers.ts
-var import_it_pushable = require("it-pushable");
+// node_modules/p-defer/index.js
+function pDefer() {
+  const deferred = {};
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+  return deferred;
+}
+
+// node_modules/it-pushable/dist/src/fifo.js
+var FixedFIFO = class {
+  buffer;
+  mask;
+  top;
+  btm;
+  next;
+  constructor(hwm) {
+    if (!(hwm > 0) || (hwm - 1 & hwm) !== 0) {
+      throw new Error("Max size for a FixedFIFO should be a power of two");
+    }
+    this.buffer = new Array(hwm);
+    this.mask = hwm - 1;
+    this.top = 0;
+    this.btm = 0;
+    this.next = null;
+  }
+  push(data) {
+    if (this.buffer[this.top] !== void 0) {
+      return false;
+    }
+    this.buffer[this.top] = data;
+    this.top = this.top + 1 & this.mask;
+    return true;
+  }
+  shift() {
+    const last = this.buffer[this.btm];
+    if (last === void 0) {
+      return void 0;
+    }
+    this.buffer[this.btm] = void 0;
+    this.btm = this.btm + 1 & this.mask;
+    return last;
+  }
+  isEmpty() {
+    return this.buffer[this.btm] === void 0;
+  }
+};
+var FIFO = class {
+  size;
+  hwm;
+  head;
+  tail;
+  constructor(options = {}) {
+    this.hwm = options.splitLimit ?? 16;
+    this.head = new FixedFIFO(this.hwm);
+    this.tail = this.head;
+    this.size = 0;
+  }
+  calculateSize(obj) {
+    if (obj?.byteLength != null) {
+      return obj.byteLength;
+    }
+    return 1;
+  }
+  push(val) {
+    if (val?.value != null) {
+      this.size += this.calculateSize(val.value);
+    }
+    if (!this.head.push(val)) {
+      const prev = this.head;
+      this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+      this.head.push(val);
+    }
+  }
+  shift() {
+    let val = this.tail.shift();
+    if (val === void 0 && this.tail.next != null) {
+      const next = this.tail.next;
+      this.tail.next = null;
+      this.tail = next;
+      val = this.tail.shift();
+    }
+    if (val?.value != null) {
+      this.size -= this.calculateSize(val.value);
+    }
+    return val;
+  }
+  isEmpty() {
+    return this.head.isEmpty();
+  }
+};
+
+// node_modules/it-pushable/dist/src/index.js
+var AbortError = class extends Error {
+  type;
+  code;
+  constructor(message, code) {
+    super(message ?? "The operation was aborted");
+    this.type = "aborted";
+    this.code = code ?? "ABORT_ERR";
+  }
+};
+function pushable(options = {}) {
+  const getNext = (buffer) => {
+    const next = buffer.shift();
+    if (next == null) {
+      return { done: true };
+    }
+    if (next.error != null) {
+      throw next.error;
+    }
+    return {
+      done: next.done === true,
+      // @ts-expect-error if done is false, value will be present
+      value: next.value
+    };
+  };
+  return _pushable(getNext, options);
+}
+function _pushable(getNext, options) {
+  options = options ?? {};
+  let onEnd = options.onEnd;
+  let buffer = new FIFO();
+  let pushable2;
+  let onNext;
+  let ended;
+  let drain = pDefer();
+  const waitNext = async () => {
+    try {
+      if (!buffer.isEmpty()) {
+        return getNext(buffer);
+      }
+      if (ended) {
+        return { done: true };
+      }
+      return await new Promise((resolve, reject) => {
+        onNext = (next) => {
+          onNext = null;
+          buffer.push(next);
+          try {
+            resolve(getNext(buffer));
+          } catch (err) {
+            reject(err);
+          }
+          return pushable2;
+        };
+      });
+    } finally {
+      if (buffer.isEmpty()) {
+        queueMicrotask(() => {
+          drain.resolve();
+          drain = pDefer();
+        });
+      }
+    }
+  };
+  const bufferNext = (next) => {
+    if (onNext != null) {
+      return onNext(next);
+    }
+    buffer.push(next);
+    return pushable2;
+  };
+  const bufferError = (err) => {
+    buffer = new FIFO();
+    if (onNext != null) {
+      return onNext({ error: err });
+    }
+    buffer.push({ error: err });
+    return pushable2;
+  };
+  const push = (value) => {
+    if (ended) {
+      return pushable2;
+    }
+    if (options?.objectMode !== true && value?.byteLength == null) {
+      throw new Error("objectMode was not true but tried to push non-Uint8Array value");
+    }
+    return bufferNext({ done: false, value });
+  };
+  const end = (err) => {
+    if (ended)
+      return pushable2;
+    ended = true;
+    return err != null ? bufferError(err) : bufferNext({ done: true });
+  };
+  const _return = () => {
+    buffer = new FIFO();
+    end();
+    return { done: true };
+  };
+  const _throw = (err) => {
+    end(err);
+    return { done: true };
+  };
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next: waitNext,
+    return: _return,
+    throw: _throw,
+    push,
+    end,
+    get readableLength() {
+      return buffer.size;
+    },
+    onEmpty: async (options2) => {
+      const signal = options2?.signal;
+      signal?.throwIfAborted();
+      if (buffer.isEmpty()) {
+        return;
+      }
+      let cancel;
+      let listener;
+      if (signal != null) {
+        cancel = new Promise((resolve, reject) => {
+          listener = () => {
+            reject(new AbortError());
+          };
+          signal.addEventListener("abort", listener);
+        });
+      }
+      try {
+        await Promise.race([
+          drain.promise,
+          cancel
+        ]);
+      } finally {
+        if (listener != null && signal != null) {
+          signal?.removeEventListener("abort", listener);
+        }
+      }
+    }
+  };
+  if (onEnd == null) {
+    return pushable2;
+  }
+  const _pushable2 = pushable2;
+  pushable2 = {
+    [Symbol.asyncIterator]() {
+      return this;
+    },
+    next() {
+      return _pushable2.next();
+    },
+    throw(err) {
+      _pushable2.throw(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    return() {
+      _pushable2.return();
+      if (onEnd != null) {
+        onEnd();
+        onEnd = void 0;
+      }
+      return { done: true };
+    },
+    push,
+    end(err) {
+      _pushable2.end(err);
+      if (onEnd != null) {
+        onEnd(err);
+        onEnd = void 0;
+      }
+      return pushable2;
+    },
+    get readableLength() {
+      return _pushable2.readableLength;
+    },
+    onEmpty: (opts) => {
+      return _pushable2.onEmpty(opts);
+    }
+  };
+  return pushable2;
+}
 
 // transport/impls/ws/server.ts
 var defaultOptions2 = {
@@ -676,8 +955,8 @@ function asClientRpc(state, proc, extendedContext) {
   };
 }
 function asClientStream(state, proc, init, extendedContext) {
-  const input = (0, import_it_pushable.pushable)({ objectMode: true });
-  const output = (0, import_it_pushable.pushable)({
+  const input = pushable({ objectMode: true });
+  const output = pushable({
     objectMode: true
   });
   (async () => {
@@ -692,7 +971,7 @@ function asClientStream(state, proc, init, extendedContext) {
   return [input, output];
 }
 function asClientSubscription(state, proc, extendedContext) {
-  const output = (0, import_it_pushable.pushable)({
+  const output = pushable({
     objectMode: true
   });
   return async (msg2) => {
@@ -703,7 +982,7 @@ function asClientSubscription(state, proc, extendedContext) {
   };
 }
 async function asClientUpload(state, proc, init, extendedContext) {
-  const input = (0, import_it_pushable.pushable)({ objectMode: true });
+  const input = pushable({ objectMode: true });
   if (init) {
     const _proc = proc;
     const result = _proc.handler({ ...extendedContext, state }, init, input).catch(catchProcError);

package/dist/util/testHelpers.d.cts

@@ -6,7 +6,7 @@ import { WebSocketClientTransport } from '../transport/impls/ws/client.cjs';
 import { TransportClientId, TransportMessage, OpaqueTransportMessage, Transport, Connection } from '../transport/index.cjs';
 import { C as Codec } from '../types-3e5768ec.js';
 import { WebSocketServerTransport } from '../transport/impls/ws/server.cjs';
-import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-3c4485f0.js';
+import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-87111051.js';
 import { Static } from '@sinclair/typebox';
 import '../connection-f7688cc1.js';
 

package/dist/util/testHelpers.d.ts

@@ -6,7 +6,7 @@ import { WebSocketClientTransport } from '../transport/impls/ws/client.js';
 import { TransportClientId, TransportMessage, OpaqueTransportMessage, Transport, Connection } from '../transport/index.js';
 import { C as Codec } from '../types-3e5768ec.js';
 import { WebSocketServerTransport } from '../transport/impls/ws/server.js';
-import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-3c4485f0.js';
+import { P as PayloadType, R as RiverError, a as Procedure, S as ServiceContext, b as Result, c as RiverUncaughtSchema } from '../builder-87111051.js';
 import { Static } from '@sinclair/typebox';
 import '../connection-8e19874c.js';
 

package/dist/util/testHelpers.js

@@ -1,6 +1,7 @@
 import {
-  UNCAUGHT_ERROR
-} from "../chunk-7WJ6YLE5.js";
+  UNCAUGHT_ERROR,
+  pushable
+} from "../chunk-IYRPZPSQ.js";
 import "../chunk-ORAG7IAU.js";
 import {
   WebSocketClientTransport
@@ -20,7 +21,6 @@ import "../chunk-SLUSVGQH.js";
 // util/testHelpers.ts
 import WebSocket from "isomorphic-ws";
 import { WebSocketServer } from "ws";
-import { pushable } from "it-pushable";
 async function createWebSocketServer(server) {
   return new WebSocketServer({ server });
 }

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.1",
+  "version": "0.10.3",
   "type": "module",
   "exports": {
     ".": {
@@ -45,12 +45,12 @@
   ],
   "dependencies": {
     "@msgpack/msgpack": "^3.0.0-beta2",
+    "it-pushable": "^3.2.3",
     "nanoid": "^4.0.2"
   },
   "peerDependencies": {
     "@sinclair/typebox": "^0.31.28",
     "isomorphic-ws": "^5.0.0",
-    "it-pushable": "^3.2.1",
     "ws": "^8.13.0"
   },
   "devDependencies": {