@replit/river 0.200.0-rc.9 → 0.200.2

package/dist/util/testHelpers.cjs

@@ -39,12 +39,15 @@ __export(testHelpers_exports, {
   createLocalWebSocketClient: () => createLocalWebSocketClient,
   createWebSocketServer: () => createWebSocketServer,
   dummySession: () => dummySession,
-  getIteratorFromStream: () => getIteratorFromStream,
+  getClientSendFn: () => getClientSendFn,
+  getReadableIterator: () => getReadableIterator,
+  getServerSendFn: () => getServerSendFn,
   getTransportConnections: () => getTransportConnections,
-  iterNext: () => iterNext,
+  isReadableDone: () => isReadableDone,
   numberOfConnections: () => numberOfConnections,
   onWsServerReady: () => onWsServerReady,
   payloadToTransportMessage: () => payloadToTransportMessage,
+  readNextResult: () => readNextResult,
   testingClientSessionOptions: () => testingClientSessionOptions,
   testingSessionOptions: () => testingSessionOptions,
   waitForMessage: () => waitForMessage
@@ -81,35 +84,8 @@ function Err(error) {
   };
 }
 
-// router/procedures.ts
-var import_typebox2 = require("@sinclair/typebox");
-var INTERNAL_RIVER_ERROR_CODE = "INTERNAL_RIVER_ERROR";
-var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
-var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
-var INVALID_REQUEST_CODE = "INVALID_REQUEST";
-var ABORT_CODE = "ABORT";
-var ResponseReaderErrorSchema = import_typebox2.Type.Object({
-  code: import_typebox2.Type.Union([
-    import_typebox2.Type.Literal(INTERNAL_RIVER_ERROR_CODE),
-    import_typebox2.Type.Literal(UNCAUGHT_ERROR_CODE),
-    import_typebox2.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
-    import_typebox2.Type.Literal(INVALID_REQUEST_CODE),
-    import_typebox2.Type.Literal(ABORT_CODE)
-  ]),
-  message: import_typebox2.Type.String()
-});
-var RequestReaderErrorSchema = import_typebox2.Type.Object({
-  code: import_typebox2.Type.Union([
-    import_typebox2.Type.Literal(UNCAUGHT_ERROR_CODE),
-    import_typebox2.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
-    import_typebox2.Type.Literal(INVALID_REQUEST_CODE),
-    import_typebox2.Type.Literal(ABORT_CODE)
-  ]),
-  message: import_typebox2.Type.String()
-});
-
 // transport/message.ts
-var import_typebox3 = require("@sinclair/typebox");
+var import_typebox2 = require("@sinclair/typebox");
 
 // transport/id.ts
 var import_nanoid = require("nanoid");
@@ -119,96 +95,91 @@ var alphabet = (0, import_nanoid.customAlphabet)(
 var generateId = () => alphabet(12);
 
 // transport/message.ts
-var TransportMessageSchema = (t) => import_typebox3.Type.Object({
-  id: import_typebox3.Type.String(),
-  from: import_typebox3.Type.String(),
-  to: import_typebox3.Type.String(),
-  seq: import_typebox3.Type.Integer(),
-  ack: import_typebox3.Type.Integer(),
-  serviceName: import_typebox3.Type.Optional(import_typebox3.Type.String()),
-  procedureName: import_typebox3.Type.Optional(import_typebox3.Type.String()),
-  streamId: import_typebox3.Type.String(),
-  controlFlags: import_typebox3.Type.Integer(),
-  tracing: import_typebox3.Type.Optional(
-    import_typebox3.Type.Object({
-      traceparent: import_typebox3.Type.String(),
-      tracestate: import_typebox3.Type.String()
+var TransportMessageSchema = (t) => import_typebox2.Type.Object({
+  id: import_typebox2.Type.String(),
+  from: import_typebox2.Type.String(),
+  to: import_typebox2.Type.String(),
+  seq: import_typebox2.Type.Integer(),
+  ack: import_typebox2.Type.Integer(),
+  serviceName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
+  procedureName: import_typebox2.Type.Optional(import_typebox2.Type.String()),
+  streamId: import_typebox2.Type.String(),
+  controlFlags: import_typebox2.Type.Integer(),
+  tracing: import_typebox2.Type.Optional(
+    import_typebox2.Type.Object({
+      traceparent: import_typebox2.Type.String(),
+      tracestate: import_typebox2.Type.String()
     })
   ),
   payload: t
 });
-var ControlMessageAckSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("ACK")
+var ControlMessageAckSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("ACK")
 });
-var ControlMessageCloseSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("CLOSE")
+var ControlMessageCloseSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("CLOSE")
 });
 var currentProtocolVersion = "v2.0";
-var ControlMessageHandshakeRequestSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("HANDSHAKE_REQ"),
-  protocolVersion: import_typebox3.Type.String(),
-  sessionId: import_typebox3.Type.String(),
+var ControlMessageHandshakeRequestSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox2.Type.String(),
+  sessionId: import_typebox2.Type.String(),
   /**
    * Specifies what the server's expected session state (from the pov of the client). This can be
    * used by the server to know whether this is a new or a reestablished connection, and whether it
    * is compatible with what it already has.
    */
-  expectedSessionState: import_typebox3.Type.Object({
+  expectedSessionState: import_typebox2.Type.Object({
     // what the client expects the server to send next
-    nextExpectedSeq: import_typebox3.Type.Integer(),
-    // TODO: remove optional once we know all servers
-    // are nextSentSeq here
-    // what the server expects the client to send next
-    nextSentSeq: import_typebox3.Type.Optional(import_typebox3.Type.Integer())
+    nextExpectedSeq: import_typebox2.Type.Integer(),
+    nextSentSeq: import_typebox2.Type.Integer()
   }),
-  metadata: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
+  metadata: import_typebox2.Type.Optional(import_typebox2.Type.Unknown())
 });
-var HandshakeErrorRetriableResponseCodes = import_typebox3.Type.Union([
-  import_typebox3.Type.Literal("SESSION_STATE_MISMATCH")
+var HandshakeErrorRetriableResponseCodes = import_typebox2.Type.Union([
+  import_typebox2.Type.Literal("SESSION_STATE_MISMATCH")
 ]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox2.Type.Union([
   // The custom validation handler rejected the handler because the client is unsupported.
-  import_typebox3.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  import_typebox2.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
   // The custom validation handler rejected the handshake.
-  import_typebox3.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+  import_typebox2.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
 ]);
-var HandshakeErrorFatalResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorFatalResponseCodes = import_typebox2.Type.Union([
   HandshakeErrorCustomHandlerFatalResponseCodes,
   // The ciient sent a handshake that doesn't comply with the extended handshake metadata.
-  import_typebox3.Type.Literal("MALFORMED_HANDSHAKE_META"),
+  import_typebox2.Type.Literal("MALFORMED_HANDSHAKE_META"),
   // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  import_typebox3.Type.Literal("MALFORMED_HANDSHAKE"),
+  import_typebox2.Type.Literal("MALFORMED_HANDSHAKE"),
   // The client's protocol version does not match the server's.
-  import_typebox3.Type.Literal("PROTOCOL_VERSION_MISMATCH")
+  import_typebox2.Type.Literal("PROTOCOL_VERSION_MISMATCH")
 ]);
-var HandshakeErrorResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorResponseCodes = import_typebox2.Type.Union([
   HandshakeErrorRetriableResponseCodes,
   HandshakeErrorFatalResponseCodes
 ]);
-var ControlMessageHandshakeResponseSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("HANDSHAKE_RESP"),
-  status: import_typebox3.Type.Union([
-    import_typebox3.Type.Object({
-      ok: import_typebox3.Type.Literal(true),
-      sessionId: import_typebox3.Type.String()
+var ControlMessageHandshakeResponseSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("HANDSHAKE_RESP"),
+  status: import_typebox2.Type.Union([
+    import_typebox2.Type.Object({
+      ok: import_typebox2.Type.Literal(true),
+      sessionId: import_typebox2.Type.String()
     }),
-    import_typebox3.Type.Object({
-      ok: import_typebox3.Type.Literal(false),
-      reason: import_typebox3.Type.String(),
-      // TODO: remove optional once we know all servers
-      // are sending code here
-      code: import_typebox3.Type.Optional(HandshakeErrorResponseCodes)
+    import_typebox2.Type.Object({
+      ok: import_typebox2.Type.Literal(false),
+      reason: import_typebox2.Type.String(),
+      code: HandshakeErrorResponseCodes
     })
   ])
 });
-var ControlMessagePayloadSchema = import_typebox3.Type.Union([
+var ControlMessagePayloadSchema = import_typebox2.Type.Union([
   ControlMessageCloseSchema,
   ControlMessageAckSchema,
   ControlMessageHandshakeRequestSchema,
   ControlMessageHandshakeResponseSchema
 ]);
 var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox3.Type.Unknown()
+  import_typebox2.Type.Unknown()
 );
 function isAck(controlFlag) {
   return (controlFlag & 1 /* AckBit */) === 1 /* AckBit */;
@@ -223,300 +194,204 @@ function coerceErrorString(err) {
 }
 
 // router/streams.ts
-var StreamDrainedError = {
-  code: "STREAM_DRAINED",
-  message: "Stream was drained"
+var ReadableBrokenError = {
+  code: "READABLE_BROKEN",
+  message: "Readable was broken before it is fully consumed"
 };
-var ReadStreamImpl = class {
+function createPromiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    // @ts-expect-error promise callbacks are sync
+    resolve,
+    // @ts-expect-error promise callbacks are sync
+    reject
+  };
+}
+var ReadableImpl = class {
   /**
-   * Whether the stream is closed.
+   * Whether the {@link Readable} is closed.
+   *
+   * Closed {@link Readable}s are done receiving values, but that doesn't affect
+   * any other aspect of the {@link Readable} such as it's consumability.
    */
   closed = false;
   /**
-   * A list of listeners that will be called when the stream is closed.
-   */
-  onCloseListeners;
-  /**
-   * Whether the user has requested to close the stream.
-   */
-  closeRequested = false;
-  /**
-   * Used to signal to the outside world that the user has requested to close the stream.
-   */
-  closeRequestCallback;
-  /**
-   * Whether the stream is locked.
+   * Whether the {@link Readable} is locked.
+   *
+   * @see {@link Readable}'s typedoc to understand locking
    */
   locked = false;
   /**
-   * Whether drain was called.
+   * Whether {@link break} was called.
+   *
+   * @see {@link break} for more information
    */
-  drained = false;
+  broken = false;
   /**
-   * This flag allows us to avoid cases where drain was called,
-   * but the stream is fully consumed and closed. We don't need
-   * to signal that drain was called.
+   * This flag allows us to avoid emitting a {@link ReadableBrokenError} after {@link break} was called
+   * in cases where the {@link queue} is fully consumed and {@link ReadableImpl} is {@link closed}. This is just an
+   * ergonomic feature to avoid emitting an error in our iteration when we don't have to.
    */
-  didDrainDisposeValues = false;
+  brokenWithValuesLeftToRead = false;
   /**
-   * A list of values that have been pushed to the stream but not yet emitted to the user.
+   * A list of values that have been pushed to the {@link ReadableImpl} but not yet emitted to the user.
    */
   queue = [];
   /**
    * Used by methods in the class to signal to the iterator that it
    * should check for the next value.
    */
-  nextPromise = null;
-  /**
-   * Resolves nextPromise
-   */
-  resolveNextPromise = null;
-  constructor(closeRequestCallback) {
-    this.closeRequestCallback = closeRequestCallback;
-    this.onCloseListeners = /* @__PURE__ */ new Set();
-  }
+  next = null;
   [Symbol.asyncIterator]() {
-    if (this.isLocked()) {
-      throw new TypeError("ReadStream is already locked");
+    if (this.locked) {
+      throw new TypeError("Readable is already locked");
     }
-    let didSignalDrain = false;
     this.locked = true;
+    let didSignalBreak = false;
     return {
       next: async () => {
-        if (this.drained && didSignalDrain) {
+        if (didSignalBreak) {
           return {
             done: true,
             value: void 0
           };
         }
         while (this.queue.length === 0) {
-          if (this.isClosed() && !this.didDrainDisposeValues) {
+          if (this.closed && !this.brokenWithValuesLeftToRead) {
             return {
               done: true,
               value: void 0
             };
           }
-          if (this.drained) {
-            didSignalDrain = true;
+          if (this.broken) {
+            didSignalBreak = true;
             return {
               done: false,
-              value: Err(StreamDrainedError)
+              value: Err(ReadableBrokenError)
             };
           }
-          if (!this.nextPromise) {
-            this.nextPromise = new Promise((resolve) => {
-              this.resolveNextPromise = resolve;
-            });
+          if (!this.next) {
+            this.next = createPromiseWithResolvers();
           }
-          await this.nextPromise;
-          this.nextPromise = null;
-          this.resolveNextPromise = null;
+          await this.next.promise;
+          this.next = null;
         }
         const value = this.queue.shift();
         return { done: false, value };
       },
       return: () => {
-        this.drain();
+        this.break();
         return { done: true, value: void 0 };
       }
     };
   }
-  unwrappedIter() {
-    const iterator = this[Symbol.asyncIterator]();
-    let unwrappedLock = false;
-    return {
-      [Symbol.asyncIterator]() {
-        if (unwrappedLock) {
-          throw new TypeError("ReadStream is already locked");
-        }
-        unwrappedLock = true;
-        return {
-          next: async () => {
-            const next = await iterator.next();
-            if (next.done) {
-              return next;
-            }
-            if (next.value.ok) {
-              return { done: false, value: next.value.payload };
-            }
-            iterator.return();
-            throw new Error(
-              `Got err result in unwrappedIter: ${next.value.payload.code} - ${next.value.payload.message}`
-            );
-          },
-          return: () => iterator.return()
-        };
-      }
-    };
-  }
-  async asArray() {
+  async collect() {
     const array = [];
     for await (const value of this) {
       array.push(value);
     }
     return array;
   }
-  drain() {
-    if (this.drained) {
+  break() {
+    if (this.broken) {
       return;
     }
     this.locked = true;
-    this.drained = true;
-    this.didDrainDisposeValues = this.queue.length > 0;
+    this.broken = true;
+    this.brokenWithValuesLeftToRead = this.queue.length > 0;
     this.queue.length = 0;
-    this.resolveNextPromise?.();
-  }
-  isClosed() {
-    return this.closed;
-  }
-  isLocked() {
-    return this.locked;
+    this.next?.resolve();
   }
-  onClose(cb) {
-    if (this.isClosed()) {
-      throw new Error("Stream is already closed");
-    }
-    this.onCloseListeners.add(cb);
-    return () => {
-      this.onCloseListeners.delete(cb);
-    };
-  }
-  requestClose() {
-    if (this.isClosed()) {
-      throw new Error("Cannot request close after stream already closed");
-    }
-    if (!this.closeRequested) {
-      this.closeRequested = true;
-      this.closeRequestCallback();
-    }
-    return new Promise((resolve) => {
-      this.onClose(() => {
-        resolve(void 0);
-      });
-    });
-  }
-  isCloseRequested() {
-    return this.closeRequested;
+  isReadable() {
+    return !this.locked && !this.broken;
   }
   /**
    * @internal meant for use within river, not exposed as a public API
    *
-   * Pushes a value to the stream.
+   * Pushes a value to be read.
    */
-  pushValue(value) {
-    if (this.drained) {
+  _pushValue(value) {
+    if (this.broken) {
       return;
     }
     if (this.closed) {
-      throw new Error("Cannot push to closed stream");
+      throw new Error("Cannot push to closed Readable");
     }
     this.queue.push(value);
-    this.resolveNextPromise?.();
+    this.next?.resolve();
   }
   /**
    * @internal meant for use within river, not exposed as a public API
    *
-   * Triggers the close of the stream. Make sure to push all remaining
+   * Triggers the close of the {@link Readable}. Make sure to push all remaining
    * values before calling this method.
    */
-  triggerClose() {
-    if (this.isClosed()) {
+  _triggerClose() {
+    if (this.closed) {
       throw new Error("Unexpected closing multiple times");
     }
     this.closed = true;
-    this.resolveNextPromise?.();
-    this.onCloseListeners.forEach((cb) => cb());
-    this.onCloseListeners.clear();
+    this.next?.resolve();
   }
   /**
    * @internal meant for use within river, not exposed as a public API
    */
-  hasValuesInQueue() {
+  _hasValuesInQueue() {
     return this.queue.length > 0;
   }
-};
-var WriteStreamImpl = class {
   /**
-   * Passed via constructor to pass on write requests
-   */
-  writeCb;
-  /**
-   * Whether the stream is closed.
+   * @internal meant for use within river, not exposed as a public API
    */
-  closed = false;
+  isClosed() {
+    return this.closed;
+  }
+};
+var WritableImpl = class {
   /**
-   * A list of listeners that will be called when the stream is closed.
+   * Passed via constructor to pass on calls to {@link write}
    */
-  onCloseListeners;
+  writeCb;
   /**
-   * Whether the reader has requested to close the stream.
+   * Passed via constructor to pass on calls to {@link close}
    */
-  closeRequested = false;
+  closeCb;
   /**
-   * A list of listeners that will be called when a close request is triggered.
+   * Whether {@link close} was called, and {@link Writable} is not writable anymore.
    */
-  onCloseRequestListeners;
-  constructor(writeCb) {
-    this.writeCb = writeCb;
-    this.onCloseListeners = /* @__PURE__ */ new Set();
-    this.onCloseRequestListeners = /* @__PURE__ */ new Set();
+  closed = false;
+  constructor(callbacks) {
+    this.writeCb = callbacks.writeCb;
+    this.closeCb = callbacks.closeCb;
   }
   write(value) {
-    if (this.isClosed()) {
-      throw new Error("Cannot write to closed stream");
+    if (this.closed) {
+      throw new Error("Cannot write to closed Writable");
     }
     this.writeCb(value);
   }
-  isClosed() {
-    return this.closed;
-  }
-  onClose(cb) {
-    if (this.isClosed()) {
-      cb();
-      return () => void 0;
-    }
-    this.onCloseListeners.add(cb);
-    return () => this.onCloseListeners.delete(cb);
+  isWritable() {
+    return !this.closed;
   }
   close() {
-    if (this.isClosed()) {
+    if (this.closed) {
       return;
     }
     this.closed = true;
-    this.onCloseListeners.forEach((cb) => cb());
-    this.onCloseListeners.clear();
-    this.onCloseRequestListeners.clear();
     this.writeCb = () => void 0;
-  }
-  isCloseRequested() {
-    return this.closeRequested;
-  }
-  onCloseRequest(cb) {
-    if (this.isClosed()) {
-      throw new Error("Stream is already closed");
-    }
-    if (this.isCloseRequested()) {
-      cb();
-      return () => void 0;
-    }
-    this.onCloseRequestListeners.add(cb);
-    return () => this.onCloseRequestListeners.delete(cb);
+    this.closeCb();
+    this.closeCb = () => void 0;
   }
   /**
    * @internal meant for use within river, not exposed as a public API
-   *
-   * Triggers a close request.
    */
-  triggerCloseRequest() {
-    if (this.isCloseRequested()) {
-      throw new Error("Cannot trigger close request multiple times");
-    }
-    if (this.isClosed()) {
-      throw new Error("Cannot trigger close request on closed stream");
-    }
-    this.closeRequested = true;
-    this.onCloseRequestListeners.forEach((cb) => cb());
-    this.onCloseRequestListeners.clear();
+  isClosed() {
+    return this.closed;
   }
 };
 
@@ -842,7 +717,7 @@ var SessionNoConnection = class extends IdentifiedSessionWithGracePeriod {
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.200.0-rc.9";
+var version = "0.200.2";
 
 // tracing/index.ts
 function createSessionTelemetryInfo(sessionId, to, from, propagationCtx) {
@@ -995,13 +870,13 @@ var SessionConnected = class extends IdentifiedSession {
     this.conn.addCloseListener(this.listeners.onConnectionClosed);
     this.conn.addErrorListener(this.listeners.onConnectionErrored);
     if (this.sendBuffer.length > 0) {
-      this.log?.debug(
-        `sending ${this.sendBuffer.length} buffered messages`,
+      this.log?.info(
+        `sending ${this.sendBuffer.length} buffered messages, starting at seq ${this.nextSeq()}`,
         this.loggingMetadata
       );
-    }
-    for (const msg of this.sendBuffer) {
-      this.conn.send(this.options.codec.toBuffer(msg));
+      for (const msg of this.sendBuffer) {
+        this.conn.send(this.options.codec.toBuffer(msg));
+      }
     }
     this.isActivelyHeartbeating = false;
     this.heartbeatHandle = setInterval(() => {
@@ -1043,6 +918,12 @@ var SessionConnected = class extends IdentifiedSession {
       }
     });
   }
+  closeConnection() {
+    this.conn.removeDataListener(this.onMessageData);
+    this.conn.removeCloseListener(this.listeners.onConnectionClosed);
+    this.conn.removeErrorListener(this.listeners.onConnectionErrored);
+    this.conn.close();
+  }
   onMessageData = (msg) => {
     const parsedMsg = this.parseMsg(msg);
     if (parsedMsg === null) {
@@ -1059,8 +940,8 @@ var SessionConnected = class extends IdentifiedSession {
           }
         );
       } else {
-        const reason = `received out-of-order msg (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack})`;
-        this.log?.error(reason, {
+        const reason = `received out-of-order msg, closing connection (got seq: ${parsedMsg.seq}, wanted seq: ${this.ack})`;
+        this.log?.warn(reason, {
           ...this.loggingMetadata,
           transportMessage: parsedMsg,
           tags: ["invariant-violation"]
@@ -1069,7 +950,7 @@ var SessionConnected = class extends IdentifiedSession {
           code: import_api2.SpanStatusCode.ERROR,
           message: reason
         });
-        this.listeners.onInvalidMessage(reason);
+        this.closeConnection();
       }
       return;
     }
@@ -1095,8 +976,10 @@ var SessionConnected = class extends IdentifiedSession {
     this.conn.removeDataListener(this.onMessageData);
     this.conn.removeCloseListener(this.listeners.onConnectionClosed);
     this.conn.removeErrorListener(this.listeners.onConnectionErrored);
-    clearInterval(this.heartbeatHandle);
-    this.heartbeatHandle = void 0;
+    if (this.heartbeatHandle) {
+      clearInterval(this.heartbeatHandle);
+      this.heartbeatHandle = void 0;
+    }
   }
   _handleClose() {
     super._handleClose();
@@ -1421,6 +1304,31 @@ var ServerSessionStateGraph = {
   }
 };
 
+// router/errors.ts
+var import_typebox3 = require("@sinclair/typebox");
+var UNCAUGHT_ERROR_CODE = "UNCAUGHT_ERROR";
+var UNEXPECTED_DISCONNECT_CODE = "UNEXPECTED_DISCONNECT";
+var INVALID_REQUEST_CODE = "INVALID_REQUEST";
+var CANCEL_CODE = "CANCEL";
+var ReaderErrorSchema = import_typebox3.Type.Union([
+  import_typebox3.Type.Object({
+    code: import_typebox3.Type.Literal(UNCAUGHT_ERROR_CODE),
+    message: import_typebox3.Type.String()
+  }),
+  import_typebox3.Type.Object({
+    code: import_typebox3.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    message: import_typebox3.Type.String()
+  }),
+  import_typebox3.Type.Object({
+    code: import_typebox3.Type.Literal(INVALID_REQUEST_CODE),
+    message: import_typebox3.Type.String()
+  }),
+  import_typebox3.Type.Object({
+    code: import_typebox3.Type.Literal(CANCEL_CODE),
+    message: import_typebox3.Type.String()
+  })
+]);
+
 // util/testHelpers.ts
 function createLocalWebSocketClient(port) {
   const sock = new import_ws.default(`ws://localhost:${port}`);
@@ -1442,11 +1350,25 @@ function onWsServerReady(server) {
     });
   });
 }
-function getIteratorFromStream(readStream) {
-  return readStream[Symbol.asyncIterator]();
+var readableIterators = /* @__PURE__ */ new WeakMap();
+function getReadableIterator(readable) {
+  let iter = readableIterators.get(readable);
+  if (!iter) {
+    iter = readable[Symbol.asyncIterator]();
+    readableIterators.set(readable, iter);
+  }
+  return iter;
 }
-async function iterNext(iter) {
-  return await iter.next().then((res) => res.value);
+async function readNextResult(readable) {
+  const res = await getReadableIterator(readable).next();
+  if (res.done) {
+    throw new Error("readNext from a done Readable");
+  }
+  return res.value;
+}
+async function isReadableDone(readable) {
+  const res = await getReadableIterator(readable).next();
+  return res.done;
 }
 function payloadToTransportMessage(payload) {
   return {
@@ -1496,6 +1418,23 @@ function dummySession() {
     currentProtocolVersion
   );
 }
+function getClientSendFn(clientTransport, serverTransport) {
+  const session = clientTransport.sessions.get(serverTransport.clientId) ?? clientTransport.createUnconnectedSession(serverTransport.clientId);
+  return clientTransport.getSessionBoundSendFn(
+    serverTransport.clientId,
+    session.id
+  );
+}
+function getServerSendFn(serverTransport, clientTransport) {
+  const session = serverTransport.sessions.get(clientTransport.clientId);
+  if (!session) {
+    throw new Error("session not found");
+  }
+  return serverTransport.getSessionBoundSendFn(
+    clientTransport.clientId,
+    session.id
+  );
+}
 function dummyCtx(state, session, extendedContext) {
   return {
     ...extendedContext,
@@ -1503,9 +1442,9 @@ function dummyCtx(state, session, extendedContext) {
     sessionId: session.id,
     from: session.from,
     metadata: {},
-    abortController: new AbortController(),
-    clientAbortSignal: new AbortController().signal,
-    onRequestFinished: () => void 0
+    // TODO might wanna hook these up!
+    cancel: () => void 0,
+    signal: new AbortController().signal
   };
 }
 function asClientRpc(state, proc, extendedContext, session = dummySession()) {
@@ -1517,38 +1456,32 @@ function asClientRpc(state, proc, extendedContext, session = dummySession()) {
   };
 }
 function createResponsePipe() {
-  const reader = new ReadStreamImpl(() => {
-    void Promise.resolve().then(() => {
-      writer.triggerCloseRequest();
-    });
-  });
-  const writer = new WriteStreamImpl(
-    (v) => {
-      reader.pushValue(v);
+  const readable = new ReadableImpl();
+  const writable = new WritableImpl({
+    writeCb: (v) => {
+      readable._pushValue(v);
+    },
+    closeCb: () => {
+      void Promise.resolve().then(() => {
+        readable._triggerClose();
+      });
     }
-  );
-  writer.onClose(() => {
-    void Promise.resolve().then(() => {
-      reader.triggerClose();
-    });
   });
-  return { reader, writer };
+  return { readable, writable };
 }
 function createRequestPipe() {
-  const reader = new ReadStreamImpl(() => {
-    void Promise.resolve().then(() => {
-      writer.triggerCloseRequest();
-    });
-  });
-  const writer = new WriteStreamImpl((v) => {
-    reader.pushValue(Ok(v));
-  });
-  writer.onClose(() => {
-    void Promise.resolve().then(() => {
-      reader.triggerClose();
-    });
+  const readable = new ReadableImpl();
+  const writable = new WritableImpl({
+    writeCb: (v) => {
+      readable._pushValue(Ok(v));
+    },
+    closeCb: () => {
+      void Promise.resolve().then(() => {
+        readable._triggerClose();
+      });
+    }
   });
-  return { reader, writer };
+  return { readable, writable };
 }
 function asClientStream(state, proc, reqInit, extendedContext, session = dummySession()) {
   const requestPipe = createRequestPipe();
@@ -1556,12 +1489,12 @@ function asClientStream(state, proc, reqInit, extendedContext, session = dummySe
   void proc.handler({
     ctx: dummyCtx(state, session, extendedContext),
     reqInit: reqInit ?? {},
-    reqReader: requestPipe.reader,
-    resWriter: responsePipe.writer
-  }).catch((err) => responsePipe.writer.write(catchProcError(err)));
+    reqReadable: requestPipe.readable,
+    resWritable: responsePipe.writable
+  }).catch((err) => responsePipe.writable.write(catchProcError(err)));
   return {
-    reqWriter: requestPipe.writer,
-    resReader: responsePipe.reader
+    reqWritable: requestPipe.writable,
+    resReadable: responsePipe.readable
   };
 }
 function asClientSubscription(state, proc, extendedContext, session = dummySession()) {
@@ -1570,9 +1503,11 @@ function asClientSubscription(state, proc, extendedContext, session = dummySessi
     void proc.handler({
       ctx: dummyCtx(state, session, extendedContext),
       reqInit: msg,
-      resWriter: responsePipe.writer
-    }).catch((err) => responsePipe.writer.write(catchProcError(err)));
-    return { resReader: responsePipe.reader };
+      resWritable: responsePipe.writable
+    }).catch(
+      (err) => responsePipe.writable.write(catchProcError(err))
+    );
+    return { resReadable: responsePipe.readable };
   };
 }
 function asClientUpload(state, proc, reqInit, extendedContext, session = dummySession()) {
@@ -1580,9 +1515,9 @@ function asClientUpload(state, proc, reqInit, extendedContext, session = dummySe
   const result = proc.handler({
     ctx: dummyCtx(state, session, extendedContext),
     reqInit: reqInit ?? {},
-    reqReader: requestPipe.reader
+    reqReadable: requestPipe.readable
   }).catch(catchProcError);
-  return [requestPipe.writer, () => result];
+  return { reqWritable: requestPipe.writable, finalize: () => result };
 }
 function getTransportConnections(transport) {
   const connections = [];
@@ -1612,12 +1547,15 @@ function closeAllConnections(transport) {
   createLocalWebSocketClient,
   createWebSocketServer,
   dummySession,
-  getIteratorFromStream,
+  getClientSendFn,
+  getReadableIterator,
+  getServerSendFn,
   getTransportConnections,
-  iterNext,
+  isReadableDone,
   numberOfConnections,
   onWsServerReady,
   payloadToTransportMessage,
+  readNextResult,
   testingClientSessionOptions,
   testingSessionOptions,
   waitForMessage