@replit/river 0.200.0-rc.9 → 0.200.1

package/dist/router/index.cjs

@@ -20,15 +20,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // router/index.ts
 var router_exports = {};
 __export(router_exports, {
-  ABORT_CODE: () => ABORT_CODE,
+  CANCEL_CODE: () => CANCEL_CODE,
   Err: () => Err,
-  INTERNAL_RIVER_ERROR_CODE: () => INTERNAL_RIVER_ERROR_CODE,
   INVALID_REQUEST_CODE: () => INVALID_REQUEST_CODE,
   Ok: () => Ok,
   Procedure: () => Procedure,
   RIVER_VERSION: () => version,
-  RequestReaderErrorSchema: () => RequestReaderErrorSchema,
-  ResponseReaderErrorSchema: () => ResponseReaderErrorSchema,
+  ReaderErrorSchema: () => ReaderErrorSchema,
   ServiceSchema: () => ServiceSchema,
   UNCAUGHT_ERROR_CODE: () => UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE: () => UNEXPECTED_DISCONNECT_CODE,
@@ -36,12 +34,28 @@ __export(router_exports, {
   createClientHandshakeOptions: () => createClientHandshakeOptions,
   createServer: () => createServer,
   createServerHandshakeOptions: () => createServerHandshakeOptions,
-  serializeSchema: () => serializeSchema
+  flattenErrorType: () => flattenErrorType,
+  serializeSchema: () => serializeSchema,
+  serializeSchemaV1Compat: () => serializeSchemaV1Compat,
+  unwrapOrThrow: () => unwrapOrThrow
 });
 module.exports = __toCommonJS(router_exports);
 
 // router/services.ts
 var import_typebox = require("@sinclair/typebox");
+function serializeSchemaV1Compat(services, handshakeSchema) {
+  const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
+    acc[name] = value.serializeV1Compat();
+    return acc;
+  }, {});
+  const schema = {
+    services: serializedServiceObject
+  };
+  if (handshakeSchema) {
+    schema.handshakeSchema = import_typebox.Type.Strict(handshakeSchema);
+  }
+  return schema;
+}
 function serializeSchema(services, handshakeSchema) {
   const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
     acc[name] = value.serialize();
@@ -178,7 +192,7 @@ var ServiceSchema = class _ServiceSchema {
    * protocol v1. This is useful to be able to continue to generate schemas for older
    * clients as they are still supported.
    */
-  serializeBackwardsCompatible() {
+  serializeV1Compat() {
     return {
       procedures: Object.fromEntries(
         Object.entries(this.procedures).map(
@@ -293,30 +307,6 @@ var ServiceScaffold = class {
 
 // 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()
-});
 function rpc({
   requestInit,
   responseData,
@@ -392,8 +382,48 @@ var Procedure = {
   stream
 };
 
-// transport/message.ts
+// 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 ErrResultSchema = (t) => import_typebox3.Type.Object({
+  ok: import_typebox3.Type.Literal(false),
+  payload: t
+});
+var ReaderErrorSchema = import_typebox3.Type.Object({
+  code: import_typebox3.Type.Union([
+    import_typebox3.Type.Literal(UNCAUGHT_ERROR_CODE),
+    import_typebox3.Type.Literal(UNEXPECTED_DISCONNECT_CODE),
+    import_typebox3.Type.Literal(INVALID_REQUEST_CODE),
+    import_typebox3.Type.Literal(CANCEL_CODE)
+  ]),
+  message: import_typebox3.Type.String()
+});
+function isUnion(schema) {
+  return schema[import_typebox3.Kind] === "Union";
+}
+function flattenErrorType(errType) {
+  if (!isUnion(errType)) {
+    return errType;
+  }
+  const flattenedTypes = [];
+  function flatten(type) {
+    if (isUnion(type)) {
+      for (const t of type.anyOf) {
+        flatten(t);
+      }
+    } else {
+      flattenedTypes.push(type);
+    }
+  }
+  flatten(errType);
+  return import_typebox3.Type.Union(flattenedTypes);
+}
+
+// transport/message.ts
+var import_typebox4 = require("@sinclair/typebox");
 
 // transport/id.ts
 var import_nanoid = require("nanoid");
@@ -403,95 +433,90 @@ 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_typebox4.Type.Object({
+  id: import_typebox4.Type.String(),
+  from: import_typebox4.Type.String(),
+  to: import_typebox4.Type.String(),
+  seq: import_typebox4.Type.Integer(),
+  ack: import_typebox4.Type.Integer(),
+  serviceName: import_typebox4.Type.Optional(import_typebox4.Type.String()),
+  procedureName: import_typebox4.Type.Optional(import_typebox4.Type.String()),
+  streamId: import_typebox4.Type.String(),
+  controlFlags: import_typebox4.Type.Integer(),
+  tracing: import_typebox4.Type.Optional(
+    import_typebox4.Type.Object({
+      traceparent: import_typebox4.Type.String(),
+      tracestate: import_typebox4.Type.String()
     })
   ),
   payload: t
 });
-var ControlMessageAckSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("ACK")
+var ControlMessageAckSchema = import_typebox4.Type.Object({
+  type: import_typebox4.Type.Literal("ACK")
 });
-var ControlMessageCloseSchema = import_typebox3.Type.Object({
-  type: import_typebox3.Type.Literal("CLOSE")
+var ControlMessageCloseSchema = import_typebox4.Type.Object({
+  type: import_typebox4.Type.Literal("CLOSE")
 });
-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_typebox4.Type.Object({
+  type: import_typebox4.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox4.Type.String(),
+  sessionId: import_typebox4.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_typebox4.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_typebox4.Type.Integer(),
+    nextSentSeq: import_typebox4.Type.Integer()
   }),
-  metadata: import_typebox3.Type.Optional(import_typebox3.Type.Unknown())
+  metadata: import_typebox4.Type.Optional(import_typebox4.Type.Unknown())
 });
-var HandshakeErrorRetriableResponseCodes = import_typebox3.Type.Union([
-  import_typebox3.Type.Literal("SESSION_STATE_MISMATCH")
+var HandshakeErrorRetriableResponseCodes = import_typebox4.Type.Union([
+  import_typebox4.Type.Literal("SESSION_STATE_MISMATCH")
 ]);
-var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorCustomHandlerFatalResponseCodes = import_typebox4.Type.Union([
   // The custom validation handler rejected the handler because the client is unsupported.
-  import_typebox3.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
+  import_typebox4.Type.Literal("REJECTED_UNSUPPORTED_CLIENT"),
   // The custom validation handler rejected the handshake.
-  import_typebox3.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
+  import_typebox4.Type.Literal("REJECTED_BY_CUSTOM_HANDLER")
 ]);
-var HandshakeErrorFatalResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorFatalResponseCodes = import_typebox4.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_typebox4.Type.Literal("MALFORMED_HANDSHAKE_META"),
   // The ciient sent a handshake that doesn't comply with ControlMessageHandshakeRequestSchema.
-  import_typebox3.Type.Literal("MALFORMED_HANDSHAKE"),
+  import_typebox4.Type.Literal("MALFORMED_HANDSHAKE"),
   // The client's protocol version does not match the server's.
-  import_typebox3.Type.Literal("PROTOCOL_VERSION_MISMATCH")
+  import_typebox4.Type.Literal("PROTOCOL_VERSION_MISMATCH")
 ]);
-var HandshakeErrorResponseCodes = import_typebox3.Type.Union([
+var HandshakeErrorResponseCodes = import_typebox4.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_typebox4.Type.Object({
+  type: import_typebox4.Type.Literal("HANDSHAKE_RESP"),
+  status: import_typebox4.Type.Union([
+    import_typebox4.Type.Object({
+      ok: import_typebox4.Type.Literal(true),
+      sessionId: import_typebox4.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_typebox4.Type.Object({
+      ok: import_typebox4.Type.Literal(false),
+      reason: import_typebox4.Type.String(),
+      code: HandshakeErrorResponseCodes
     })
   ])
 });
-var ControlMessagePayloadSchema = import_typebox3.Type.Union([
+var ControlMessagePayloadSchema = import_typebox4.Type.Union([
   ControlMessageCloseSchema,
   ControlMessageAckSchema,
   ControlMessageHandshakeRequestSchema,
   ControlMessageHandshakeResponseSchema
 ]);
 var OpaqueTransportMessageSchema = TransportMessageSchema(
-  import_typebox3.Type.Unknown()
+  import_typebox4.Type.Unknown()
 );
 function closeStreamMessage(streamId) {
   return {
@@ -502,19 +527,10 @@ function closeStreamMessage(streamId) {
     }
   };
 }
-function requestCloseStreamMessage(streamId) {
+function cancelMessage(streamId, payload) {
   return {
     streamId,
-    controlFlags: 16 /* StreamCloseRequestBit */,
-    payload: {
-      type: "CLOSE"
-    }
-  };
-}
-function abortMessage(streamId, payload) {
-  return {
-    streamId,
-    controlFlags: 4 /* StreamAbortBit */,
+    controlFlags: 4 /* StreamCancelBit */,
     payload
   };
 }
@@ -530,37 +546,27 @@ function isStreamClose(controlFlag) {
     (controlFlag & 8 /* StreamClosedBit */) === 8 /* StreamClosedBit */
   );
 }
-function isStreamCloseRequest(controlFlag) {
-  return (
-    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
-    (controlFlag & 16 /* StreamCloseRequestBit */) === 16 /* StreamCloseRequestBit */
-  );
-}
-function isStreamAbort(controlFlag) {
+function isStreamCancel(controlFlag) {
   return (
     /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
-    (controlFlag & 4 /* StreamAbortBit */) === 4 /* StreamAbortBit */
+    (controlFlag & 4 /* StreamCancelBit */) === 4 /* StreamCancelBit */
   );
 }
 
 // router/result.ts
-var import_typebox4 = require("@sinclair/typebox");
-var ErrResultSchema = (t) => import_typebox4.Type.Object({
-  ok: import_typebox4.Type.Literal(false),
-  payload: t
-});
-var AnyResultSchema = import_typebox4.Type.Union([
-  import_typebox4.Type.Object({
-    ok: import_typebox4.Type.Literal(false),
-    payload: import_typebox4.Type.Object({
-      code: import_typebox4.Type.String(),
-      message: import_typebox4.Type.String(),
-      extras: import_typebox4.Type.Optional(import_typebox4.Type.Unknown())
+var import_typebox5 = require("@sinclair/typebox");
+var AnyResultSchema = import_typebox5.Type.Union([
+  import_typebox5.Type.Object({
+    ok: import_typebox5.Type.Literal(false),
+    payload: import_typebox5.Type.Object({
+      code: import_typebox5.Type.String(),
+      message: import_typebox5.Type.String(),
+      extras: import_typebox5.Type.Optional(import_typebox5.Type.Unknown())
     })
   }),
-  import_typebox4.Type.Object({
-    ok: import_typebox4.Type.Literal(true),
-    payload: import_typebox4.Type.Unknown()
+  import_typebox5.Type.Object({
+    ok: import_typebox5.Type.Literal(true),
+    payload: import_typebox5.Type.Unknown()
   })
 ]);
 function Ok(payload) {
@@ -575,12 +581,20 @@ function Err(error) {
     payload: error
   };
 }
+function unwrapOrThrow(result) {
+  if (result.ok) {
+    return result.payload;
+  }
+  throw new Error(
+    `Cannot non-ok result, got: ${result.payload.code} - ${result.payload.message}`
+  );
+}
 
 // tracing/index.ts
 var import_api = require("@opentelemetry/api");
 
 // package.json
-var version = "0.200.0-rc.9";
+var version = "0.200.1";
 
 // tracing/index.ts
 function getPropagationContext(ctx) {
@@ -644,306 +658,210 @@ function createHandlerSpan(kind, serviceName, procedureName, streamId, tracing,
 var tracer = import_api.trace.getTracer("river", version);
 
 // 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;
-  }
-  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);
-      });
-    });
+    this.next?.resolve();
   }
-  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;
   }
 };
 
 // router/client.ts
 var import_value = require("@sinclair/typebox/value");
-var OutputErrResultSchema = ErrResultSchema(ResponseReaderErrorSchema);
+var ReaderErrResultSchema = ErrResultSchema(ReaderErrorSchema);
 var noop = () => {
 };
 function _createRecursiveProxy(callback, path) {
@@ -1004,6 +922,11 @@ function createClient(transport, serverId, providedClientOptions = {}) {
   }, []);
 }
 function handleProc(procType, transport, serverId, init, serviceName, procedureName, abortSignal) {
+  const session = transport.sessions.get(serverId) ?? transport.createUnconnectedSession(serverId);
+  const sessionScopedSend = transport.getSessionBoundSendFn(
+    serverId,
+    session.id
+  );
   const procClosesWithInit = procType === "rpc" || procType === "subscription";
   const streamId = generateId();
   const { span, ctx } = createProcTelemetryInfo(
@@ -1014,61 +937,61 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     streamId
   );
   let cleanClose = true;
-  const reqWriter = new WriteStreamImpl((rawIn) => {
-    transport.send(serverId, {
-      streamId,
-      payload: rawIn,
-      controlFlags: 0,
-      tracing: getPropagationContext(ctx)
-    });
-  });
-  reqWriter.onClose(() => {
-    span.addEvent("reqWriter closed");
-    if (!procClosesWithInit && cleanClose) {
-      transport.send(serverId, closeStreamMessage(streamId));
-    }
-    if (resReader.isClosed()) {
-      cleanup();
+  const reqWritable = new WritableImpl({
+    writeCb: (rawIn) => {
+      sessionScopedSend({
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
+      });
+    },
+    // close callback
+    closeCb: () => {
+      span.addEvent("reqWritable closed");
+      if (!procClosesWithInit && cleanClose) {
+        sessionScopedSend(closeStreamMessage(streamId));
+      }
+      if (resReadable.isClosed()) {
+        cleanup();
+      }
     }
   });
-  const resReader = new ReadStreamImpl(() => {
-    transport.send(serverId, requestCloseStreamMessage(streamId));
-  });
-  resReader.onClose(() => {
-    span.addEvent("resReader closed");
-    if (reqWriter.isClosed()) {
+  const resReadable = new ReadableImpl();
+  const closeReadable = () => {
+    resReadable._triggerClose();
+    span.addEvent("resReadable closed");
+    if (reqWritable.isClosed()) {
       cleanup();
     }
-  });
+  };
   function cleanup() {
     transport.removeEventListener("message", onMessage);
     transport.removeEventListener("sessionStatus", onSessionStatus);
-    abortSignal?.removeEventListener("abort", onClientAbort);
+    abortSignal?.removeEventListener("abort", onClientCancel);
     span.end();
   }
-  function onClientAbort() {
-    if (resReader.isClosed() && reqWriter.isClosed()) {
+  function onClientCancel() {
+    if (resReadable.isClosed() && reqWritable.isClosed()) {
       return;
     }
-    span.addEvent("sending abort");
+    span.addEvent("sending cancel");
     cleanClose = false;
-    if (!resReader.isClosed()) {
-      resReader.pushValue(
+    if (!resReadable.isClosed()) {
+      resReadable._pushValue(
         Err({
-          code: ABORT_CODE,
-          message: "Aborted by client"
+          code: CANCEL_CODE,
+          message: "cancelled by client"
         })
       );
-      resReader.triggerClose();
+      closeReadable();
     }
-    reqWriter.close();
-    transport.send(
-      serverId,
-      abortMessage(
+    reqWritable.close();
+    sessionScopedSend(
+      cancelMessage(
         streamId,
         Err({
-          code: ABORT_CODE,
-          message: "Aborted by client"
+          code: CANCEL_CODE,
+          message: "cancelled by client"
         })
       )
     );
@@ -1077,47 +1000,44 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     if (msg.streamId !== streamId)
       return;
     if (msg.to !== transport.clientId) {
-      transport.log?.error("Got stream message from unexpected client", {
+      transport.log?.error("got stream message from unexpected client", {
         clientId: transport.clientId,
         transportMessage: msg
       });
       return;
     }
-    if (isStreamCloseRequest(msg.controlFlags)) {
-      reqWriter.triggerCloseRequest();
-    }
-    if (isStreamAbort(msg.controlFlags)) {
+    if (isStreamCancel(msg.controlFlags)) {
       cleanClose = false;
-      span.addEvent("received abort");
-      let abortResult;
-      if (import_value.Value.Check(OutputErrResultSchema, msg.payload)) {
-        abortResult = msg.payload;
+      span.addEvent("received cancel");
+      let cancelResult;
+      if (import_value.Value.Check(ReaderErrResultSchema, msg.payload)) {
+        cancelResult = msg.payload;
       } else {
-        abortResult = Err({
-          code: ABORT_CODE,
-          message: "Stream aborted with invalid payload"
+        cancelResult = Err({
+          code: CANCEL_CODE,
+          message: "stream cancelled with invalid payload"
         });
         transport.log?.error(
-          "Got stream abort without a valid protocol error",
+          "got stream cancel without a valid protocol error",
           {
             clientId: transport.clientId,
             transportMessage: msg,
             validationErrors: [
-              ...import_value.Value.Errors(OutputErrResultSchema, msg.payload)
+              ...import_value.Value.Errors(ReaderErrResultSchema, msg.payload)
             ]
           }
         );
       }
-      if (!resReader.isClosed()) {
-        resReader.pushValue(abortResult);
-        resReader.triggerClose();
+      if (!resReadable.isClosed()) {
+        resReadable._pushValue(cancelResult);
+        closeReadable();
       }
-      reqWriter.close();
+      reqWritable.close();
       return;
     }
-    if (resReader.isClosed()) {
-      span.recordException("Received message after output stream is closed");
-      transport.log?.error("Received message after output stream is closed", {
+    if (resReadable.isClosed()) {
+      span.recordException("received message after response stream is closed");
+      transport.log?.error("received message after response stream is closed", {
         clientId: transport.clientId,
         transportMessage: msg
       });
@@ -1125,7 +1045,7 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     }
     if (!import_value.Value.Check(ControlMessageCloseSchema, msg.payload)) {
       if (import_value.Value.Check(AnyResultSchema, msg.payload)) {
-        resReader.pushValue(msg.payload);
+        resReadable._pushValue(msg.payload);
       } else {
         transport.log?.error(
           "Got non-control payload, but was not a valid result",
@@ -1138,33 +1058,36 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
       }
     }
     if (isStreamClose(msg.controlFlags)) {
-      span.addEvent("received output close");
-      resReader.triggerClose();
+      span.addEvent("received response close");
+      if (resReadable.isClosed()) {
+        transport.log?.error(
+          "received stream close but readable was already closed"
+        );
+      } else {
+        closeReadable();
+      }
     }
   }
   function onSessionStatus(evt) {
-    if (evt.status !== "disconnect") {
-      return;
-    }
-    if (evt.session.to !== serverId) {
+    if (evt.status !== "disconnect" || evt.session.to !== serverId || session.id !== evt.session.id) {
       return;
     }
     cleanClose = false;
-    if (!resReader.isClosed()) {
-      resReader.pushValue(
+    if (!resReadable.isClosed()) {
+      resReadable._pushValue(
         Err({
           code: UNEXPECTED_DISCONNECT_CODE,
           message: `${serverId} unexpectedly disconnected`
         })
       );
+      closeReadable();
     }
-    reqWriter.close();
-    resReader.triggerClose();
+    reqWritable.close();
   }
-  abortSignal?.addEventListener("abort", onClientAbort);
+  abortSignal?.addEventListener("abort", onClientCancel);
   transport.addEventListener("message", onMessage);
   transport.addEventListener("sessionStatus", onSessionStatus);
-  transport.send(serverId, {
+  sessionScopedSend({
     streamId,
     serviceName,
     procedureName,
@@ -1173,34 +1096,39 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     controlFlags: procClosesWithInit ? 2 /* StreamOpenBit */ | 8 /* StreamClosedBit */ : 2 /* StreamOpenBit */
   });
   if (procClosesWithInit) {
-    reqWriter.close();
+    reqWritable.close();
   }
   if (procType === "subscription") {
-    return { resReader };
+    return {
+      resReadable
+    };
   }
   if (procType === "rpc") {
-    return getSingleMessage(resReader, transport.log);
+    return getSingleMessage(resReadable, transport.log);
   }
   if (procType === "upload") {
     let didFinalize = false;
     return {
-      reqWriter,
-      async finalize() {
+      reqWritable,
+      finalize: () => {
         if (didFinalize) {
           throw new Error("upload stream already finalized");
         }
         didFinalize = true;
-        if (!reqWriter.isClosed()) {
-          reqWriter.close();
+        if (!reqWritable.isClosed()) {
+          reqWritable.close();
         }
-        return getSingleMessage(resReader, transport.log);
+        return getSingleMessage(resReadable, transport.log);
       }
     };
   }
-  return { reqWriter, resReader };
+  return {
+    resReadable,
+    reqWritable
+  };
 }
-async function getSingleMessage(resReader, log) {
-  const ret = await resReader.asArray();
+async function getSingleMessage(resReadable, log) {
+  const ret = await resReadable.collect();
   if (ret.length > 1) {
     log?.error("Expected single message from server, got multiple");
   }
@@ -1208,6 +1136,7 @@ async function getSingleMessage(resReader, log) {
 }
 
 // router/server.ts
+var import_typebox6 = require("@sinclair/typebox");
 var import_value2 = require("@sinclair/typebox/value");
 
 // util/stringify.ts
@@ -1220,23 +1149,28 @@ function coerceErrorString(err) {
 
 // router/server.ts
 var import_api2 = require("@opentelemetry/api");
-var InputErrResultSchema = ErrResultSchema(RequestReaderErrorSchema);
+var CancelResultSchema = ErrResultSchema(
+  import_typebox6.Type.Object({
+    code: import_typebox6.Type.Literal(CANCEL_CODE),
+    message: import_typebox6.Type.String()
+  })
+);
 var RiverServer = class {
   transport;
   contextMap;
   log;
   /**
-   * We create a tombstones for streams aborted by the server
+   * We create a tombstones for streams cancelled by the server
    * so that we don't hit errors when the client has inflight
-   * requests it sent before it saw the abort.
-   * We track aborted streams for every session separately, so
+   * requests it sent before it saw the cancel.
+   * We track cancelled streams for every client separately, so
    * that bad clients don't affect good clients.
    */
-  serverAbortedStreams;
-  maxAbortedStreamTombstonesPerSession;
-  openStreams;
+  serverCancelledStreams;
+  maxCancelledStreamTombstonesPerSession;
+  streams;
   services;
-  constructor(transport, services, handshakeOptions, extendedContext, maxAbortedStreamTombstonesPerSession = 200) {
+  constructor(transport, services, handshakeOptions, extendedContext, maxCancelledStreamTombstonesPerSession = 200) {
     const instances = {};
     this.services = instances;
     this.contextMap = /* @__PURE__ */ new Map();
@@ -1252,34 +1186,40 @@ var RiverServer = class {
       transport.extendHandshake(handshakeOptions);
     }
     this.transport = transport;
-    this.openStreams = /* @__PURE__ */ new Set();
-    this.serverAbortedStreams = /* @__PURE__ */ new Map();
-    this.maxAbortedStreamTombstonesPerSession = maxAbortedStreamTombstonesPerSession;
+    this.streams = /* @__PURE__ */ new Map();
+    this.serverCancelledStreams = /* @__PURE__ */ new Map();
+    this.maxCancelledStreamTombstonesPerSession = maxCancelledStreamTombstonesPerSession;
     this.log = transport.log;
-    const handleMessage = (msg) => {
-      if (msg.to !== this.transport.clientId) {
+    const handleCreatingNewStreams = (message) => {
+      if (message.to !== this.transport.clientId) {
         this.log?.info(
           `got msg with destination that isn't this server, ignoring`,
           {
             clientId: this.transport.clientId,
-            transportMessage: msg
+            transportMessage: message
           }
         );
         return;
       }
-      if (this.openStreams.has(msg.streamId)) {
+      const streamId = message.streamId;
+      const stream2 = this.streams.get(streamId);
+      if (stream2) {
+        stream2.handleMsg(message);
         return;
       }
-      if (this.serverAbortedStreams.get(msg.from)?.has(msg.streamId)) {
+      if (this.serverCancelledStreams.get(message.from)?.has(streamId)) {
         return;
       }
-      const validated = this.validateNewProcStream(msg);
-      if (!validated) {
+      const newStreamProps = this.validateNewProcStream(message);
+      if (!newStreamProps) {
         return;
       }
-      this.createNewProcStream(validated);
+      const newStream = this.createNewProcStream({
+        ...newStreamProps,
+        ...message
+      });
+      this.streams.set(streamId, newStream);
     };
-    this.transport.addEventListener("message", handleMessage);
     const handleSessionStatus = (evt) => {
       if (evt.status !== "disconnect")
         return;
@@ -1288,256 +1228,248 @@ var RiverServer = class {
         `got session disconnect from ${disconnectedClientId}, cleaning up streams`,
         evt.session.loggingMetadata
       );
-      this.serverAbortedStreams.delete(disconnectedClientId);
+      for (const stream2 of this.streams.values()) {
+        if (stream2.from === disconnectedClientId) {
+          stream2.handleSessionDisconnect();
+        }
+      }
+      this.serverCancelledStreams.delete(disconnectedClientId);
     };
-    this.transport.addEventListener("sessionStatus", handleSessionStatus);
-    this.transport.addEventListener("transportStatus", (evt) => {
+    const handleTransportStatus = (evt) => {
       if (evt.status !== "closed")
         return;
-      this.transport.removeEventListener("message", handleMessage);
+      this.transport.removeEventListener("message", handleCreatingNewStreams);
       this.transport.removeEventListener("sessionStatus", handleSessionStatus);
-    });
-  }
-  createNewProcStream({
-    procedure,
-    procedureName,
-    service,
-    serviceName,
-    sessionMetadata,
-    loggingMetadata,
-    streamId,
-    controlFlags,
-    initPayload,
-    from,
-    sessionId,
-    tracingCtx,
-    protocolVersion,
-    passInitAsDataForBackwardsCompat
-  }) {
-    this.openStreams.add(streamId);
-    let cleanClose = true;
-    const onServerAbort = (errResult) => {
-      if (reqReader.isClosed() && resWriter.isClosed()) {
-        return;
-      }
-      cleanClose = false;
-      if (!reqReader.isClosed()) {
-        reqReader.pushValue(errResult);
-        reqReader.triggerClose();
-      }
-      resWriter.close();
-      this.abortStream(from, streamId, errResult);
-    };
-    const onHandlerAbort = () => {
-      onServerAbort(
-        Err({
-          code: ABORT_CODE,
-          message: "Aborted by server procedure handler"
-        })
+      this.transport.removeEventListener(
+        "transportStatus",
+        handleTransportStatus
       );
     };
-    const handlerAbortController = new AbortController();
-    handlerAbortController.signal.addEventListener("abort", onHandlerAbort);
-    const clientAbortController = new AbortController();
-    const onSessionStatus = (evt) => {
-      if (evt.status !== "disconnect") {
-        return;
-      }
-      if (evt.session.to !== from) {
-        return;
-      }
-      cleanClose = false;
-      const errPayload = {
-        code: UNEXPECTED_DISCONNECT_CODE,
-        message: `client unexpectedly disconnected`
-      };
-      if (!reqReader.isClosed()) {
-        reqReader.pushValue(Err(errPayload));
-        reqReader.triggerClose();
-      }
-      clientAbortController.abort(errPayload);
-      resWriter.close();
-    };
-    this.transport.addEventListener("sessionStatus", onSessionStatus);
+    this.transport.addEventListener("message", handleCreatingNewStreams);
+    this.transport.addEventListener("sessionStatus", handleSessionStatus);
+    this.transport.addEventListener("transportStatus", handleTransportStatus);
+  }
+  createNewProcStream(props) {
+    const {
+      streamId,
+      initialSession,
+      procedureName,
+      serviceName,
+      procedure,
+      sessionMetadata,
+      serviceContext,
+      initPayload,
+      tracingCtx,
+      procClosesWithInit,
+      passInitAsDataForBackwardsCompat
+    } = props;
+    const {
+      to: from,
+      loggingMetadata,
+      protocolVersion,
+      id: sessionId
+    } = initialSession;
+    let cleanClose = true;
     const onMessage = (msg) => {
-      if (streamId !== msg.streamId) {
-        return;
-      }
       if (msg.from !== from) {
-        this.log?.error("Got stream message from unexpected client", {
+        this.log?.error("got stream message from unexpected client", {
           ...loggingMetadata,
-          clientId: this.transport.clientId,
           transportMessage: msg,
           tags: ["invariant-violation"]
         });
         return;
       }
-      if (isStreamCloseRequest(msg.controlFlags)) {
-        resWriter.triggerCloseRequest();
-      }
-      if (isStreamAbortBackwardsCompat(msg.controlFlags, protocolVersion)) {
-        let abortResult;
-        if (import_value2.Value.Check(InputErrResultSchema, msg.payload)) {
-          abortResult = msg.payload;
+      if (isStreamCancelBackwardsCompat(msg.controlFlags, protocolVersion)) {
+        let cancelResult;
+        if (import_value2.Value.Check(CancelResultSchema, msg.payload)) {
+          cancelResult = msg.payload;
         } else {
-          abortResult = Err({
-            code: ABORT_CODE,
-            message: "Stream aborted, client sent invalid payload"
+          cancelResult = Err({
+            code: CANCEL_CODE,
+            message: "stream cancelled, client sent invalid payload"
           });
-          this.log?.warn("Got stream abort without a valid protocol error", {
+          this.log?.warn("got stream cancel without a valid protocol error", {
             ...loggingMetadata,
-            clientId: this.transport.clientId,
             transportMessage: msg,
             validationErrors: [
-              ...import_value2.Value.Errors(InputErrResultSchema, msg.payload)
+              ...import_value2.Value.Errors(CancelResultSchema, msg.payload)
             ],
             tags: ["invalid-request"]
           });
         }
-        if (!reqReader.isClosed()) {
-          reqReader.pushValue(abortResult);
-          reqReader.triggerClose();
+        if (!reqReadable.isClosed()) {
+          reqReadable._pushValue(cancelResult);
+          closeReadable();
         }
-        resWriter.close();
-        clientAbortController.abort(abortResult.payload);
+        resWritable.close();
         return;
       }
-      if (reqReader.isClosed()) {
-        this.log?.warn("Received message after input stream is closed", {
+      if (reqReadable.isClosed()) {
+        this.log?.warn("received message after request stream is closed", {
           ...loggingMetadata,
-          clientId: this.transport.clientId,
           transportMessage: msg,
           tags: ["invalid-request"]
         });
-        onServerAbort(
-          Err({
-            code: INVALID_REQUEST_CODE,
-            message: "Received message after input stream is closed"
-          })
-        );
+        onServerCancel({
+          code: INVALID_REQUEST_CODE,
+          message: "received message after request stream is closed"
+        });
         return;
       }
       if ("requestData" in procedure && import_value2.Value.Check(procedure.requestData, msg.payload)) {
-        reqReader.pushValue(Ok(msg.payload));
-      } else if (!import_value2.Value.Check(ControlMessagePayloadSchema, msg.payload)) {
-        const validationErrors = [
+        reqReadable._pushValue(Ok(msg.payload));
+        if (isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
+          closeReadable();
+        }
+        return;
+      }
+      if (import_value2.Value.Check(ControlMessagePayloadSchema, msg.payload) && isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
+        closeReadable();
+        return;
+      }
+      let validationErrors;
+      let errMessage;
+      if ("requestData" in procedure) {
+        errMessage = "expected requestData or control payload";
+        validationErrors = [
+          ...import_value2.Value.Errors(procedure.responseData, msg.payload)
+        ];
+      } else {
+        validationErrors = [
           ...import_value2.Value.Errors(ControlMessagePayloadSchema, msg.payload)
         ];
-        let errMessage = "Expected control payload for procedure with no input";
-        if ("requestData" in procedure) {
-          errMessage = "Expected either control or input payload, validation failed for both";
-          validationErrors.push(
-            ...import_value2.Value.Errors(procedure.responseData, msg.payload)
-          );
+        errMessage = "expected control payload";
+      }
+      this.log?.warn(errMessage, {
+        ...loggingMetadata,
+        transportMessage: msg,
+        validationErrors,
+        tags: ["invalid-request"]
+      });
+      onServerCancel({
+        code: INVALID_REQUEST_CODE,
+        message: errMessage
+      });
+    };
+    const procStream = {
+      from,
+      streamId,
+      procedureName,
+      serviceName,
+      sessionMetadata,
+      procedure,
+      handleMsg: onMessage,
+      handleSessionDisconnect: () => {
+        cleanClose = false;
+        const errPayload = {
+          code: UNEXPECTED_DISCONNECT_CODE,
+          message: "client unexpectedly disconnected"
+        };
+        if (!reqReadable.isClosed()) {
+          reqReadable._pushValue(Err(errPayload));
+          closeReadable();
         }
-        this.log?.warn(errMessage, {
-          ...loggingMetadata,
-          clientId: this.transport.clientId,
-          transportMessage: msg,
-          validationErrors,
-          tags: ["invalid-request"]
-        });
-        onServerAbort(
-          Err({
-            code: INVALID_REQUEST_CODE,
-            message: errMessage
-          })
-        );
+        resWritable.close();
       }
-      if (isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
-        reqReader.triggerClose();
+    };
+    const sessionScopedSend = this.transport.getSessionBoundSendFn(
+      from,
+      sessionId
+    );
+    const cancelStream = (streamId2, payload) => {
+      this.cancelStream(from, sessionScopedSend, streamId2, payload);
+    };
+    const onServerCancel = (e) => {
+      if (reqReadable.isClosed() && resWritable.isClosed()) {
+        return;
+      }
+      cleanClose = false;
+      const result = Err(e);
+      if (!reqReadable.isClosed()) {
+        reqReadable._pushValue(result);
+        closeReadable();
       }
+      resWritable.close();
+      cancelStream(streamId, result);
     };
-    this.transport.addEventListener("message", onMessage);
-    const onFinishedCallbacks = [];
+    const finishedController = new AbortController();
     const cleanup = () => {
-      this.transport.removeEventListener("message", onMessage);
-      this.transport.removeEventListener("sessionStatus", onSessionStatus);
-      handlerAbortController.signal.addEventListener("abort", onHandlerAbort);
-      this.openStreams.delete(streamId);
-      onFinishedCallbacks.forEach((cb) => {
-        try {
-          cb();
-        } catch {
-        }
-      });
-      onFinishedCallbacks.length = 0;
+      finishedController.abort();
+      this.streams.delete(streamId);
     };
     const procClosesWithResponse = procedure.type === "rpc" || procedure.type === "upload";
-    const reqReader = new ReadStreamImpl(() => {
-      this.transport.send(from, requestCloseStreamMessage(streamId));
-    });
-    reqReader.onClose(() => {
+    const reqReadable = new ReadableImpl();
+    const closeReadable = () => {
+      reqReadable._triggerClose();
       if (protocolVersion === "v1.1") {
-        if (!procClosesWithResponse && !resWriter.isClosed()) {
-          resWriter.close();
+        if (!procClosesWithResponse && !resWritable.isClosed()) {
+          resWritable.close();
         }
       }
-      if (resWriter.isClosed()) {
+      if (resWritable.isClosed()) {
         cleanup();
       }
-    });
+    };
     if (passInitAsDataForBackwardsCompat) {
-      reqReader.pushValue(Ok(initPayload));
+      reqReadable._pushValue(Ok(initPayload));
     }
-    const resWriter = new WriteStreamImpl((response) => {
-      this.transport.send(from, {
-        streamId,
-        controlFlags: procClosesWithResponse ? getStreamCloseBackwardsCompat(protocolVersion) : 0,
-        payload: response
-      });
-    });
-    resWriter.onClose(() => {
-      if (!procClosesWithResponse && cleanClose) {
-        const message = closeStreamMessage(streamId);
-        message.controlFlags = getStreamCloseBackwardsCompat(protocolVersion);
-        this.transport.send(from, closeStreamMessage(streamId));
-      }
-      if (protocolVersion === "v1.1") {
-        if (!reqReader.isClosed()) {
-          reqReader.triggerClose();
+    const resWritable = new WritableImpl({
+      writeCb: (response) => {
+        sessionScopedSend({
+          streamId,
+          controlFlags: procClosesWithResponse ? getStreamCloseBackwardsCompat(protocolVersion) : 0,
+          payload: response
+        });
+        if (procClosesWithResponse) {
+          resWritable.close();
+        }
+      },
+      // close callback
+      closeCb: () => {
+        if (!procClosesWithResponse && cleanClose) {
+          const message = closeStreamMessage(streamId);
+          message.controlFlags = getStreamCloseBackwardsCompat(protocolVersion);
+          sessionScopedSend(message);
+        }
+        if (protocolVersion === "v1.1") {
+          if (!reqReadable.isClosed()) {
+            closeReadable();
+          }
+        }
+        if (reqReadable.isClosed()) {
+          cleanup();
         }
-      }
-      if (reqReader.isClosed()) {
-        cleanup();
       }
     });
     const onHandlerError = (err, span) => {
       const errorMsg = coerceErrorString(err);
       span.recordException(err instanceof Error ? err : new Error(errorMsg));
       span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-      onServerAbort(
-        Err({
-          code: UNCAUGHT_ERROR_CODE,
-          message: errorMsg
-        })
-      );
+      onServerCancel({
+        code: UNCAUGHT_ERROR_CODE,
+        message: errorMsg
+      });
     };
-    if (isStreamCloseBackwardsCompat(controlFlags, protocolVersion)) {
-      reqReader.triggerClose();
+    if (procClosesWithInit) {
+      closeReadable();
     } else if (procedure.type === "rpc" || procedure.type === "subscription") {
-      this.log?.warn(`${procedure.type} sent an init without a stream close`, {
+      this.log?.warn("sent an init without a stream close", {
         ...loggingMetadata,
         clientId: this.transport.clientId
       });
     }
-    const serviceContextWithTransportInfo = {
-      ...this.getContext(service, serviceName),
+    const handlerContext = {
+      ...serviceContext,
       from,
       sessionId,
       metadata: sessionMetadata,
-      abortController: handlerAbortController,
-      clientAbortSignal: clientAbortController.signal,
-      onRequestFinished: (cb) => {
-        if (reqReader.isClosed() && resWriter.isClosed()) {
-          try {
-            cb();
-          } catch {
-          }
-          return;
-        }
-        onFinishedCallbacks.push(cb);
-      }
+      cancel: () => {
+        onServerCancel({
+          code: CANCEL_CODE,
+          message: "cancelled by server procedure handler"
+        });
+      },
+      signal: finishedController.signal
     };
     switch (procedure.type) {
       case "rpc":
@@ -1549,15 +1481,14 @@ var RiverServer = class {
           tracingCtx,
           async (span) => {
             try {
-              const outputMessage = await procedure.handler({
-                ctx: serviceContextWithTransportInfo,
+              const responsePayload = await procedure.handler({
+                ctx: handlerContext,
                 reqInit: initPayload
               });
-              if (resWriter.isClosed()) {
+              if (resWritable.isClosed()) {
                 return;
               }
-              resWriter.write(outputMessage);
-              resWriter.close();
+              resWritable.write(responsePayload);
             } catch (err) {
               onHandlerError(err, span);
             } finally {
@@ -1576,10 +1507,10 @@ var RiverServer = class {
           async (span) => {
             try {
               await procedure.handler({
-                ctx: serviceContextWithTransportInfo,
+                ctx: handlerContext,
                 reqInit: initPayload,
-                reqReader,
-                resWriter
+                reqReadable,
+                resWritable
               });
             } catch (err) {
               onHandlerError(err, span);
@@ -1599,9 +1530,9 @@ var RiverServer = class {
           async (span) => {
             try {
               await procedure.handler({
-                ctx: serviceContextWithTransportInfo,
-                reqInit: passInitAsDataForBackwardsCompat ? {} : initPayload,
-                resWriter
+                ctx: handlerContext,
+                reqInit: initPayload,
+                resWritable
               });
             } catch (err) {
               onHandlerError(err, span);
@@ -1620,16 +1551,15 @@ var RiverServer = class {
           tracingCtx,
           async (span) => {
             try {
-              const outputMessage = await procedure.handler({
-                ctx: serviceContextWithTransportInfo,
-                reqInit: passInitAsDataForBackwardsCompat ? {} : initPayload,
-                reqReader
+              const responsePayload = await procedure.handler({
+                ctx: handlerContext,
+                reqInit: initPayload,
+                reqReadable
               });
-              if (resWriter.isClosed()) {
+              if (resWritable.isClosed()) {
                 return;
               }
-              resWriter.write(outputMessage);
-              resWriter.close();
+              resWritable.write(responsePayload);
             } catch (err) {
               onHandlerError(err, span);
             } finally {
@@ -1638,16 +1568,8 @@ var RiverServer = class {
           }
         );
         break;
-      default:
-        this.log?.error(
-          `got request for invalid procedure type ${procedure.type} at ${serviceName}.${procedureName}`,
-          {
-            ...loggingMetadata,
-            tags: ["invariant-violation"]
-          }
-        );
-        return;
     }
+    return procStream;
   }
   getContext(service, serviceName) {
     const context2 = this.contextMap.get(service);
@@ -1664,22 +1586,20 @@ var RiverServer = class {
   validateNewProcStream(initMessage) {
     const session = this.transport.sessions.get(initMessage.from);
     if (!session) {
-      const errMessage = `couldn't find a session for ${initMessage.from}`;
       this.log?.error(`couldn't find session for ${initMessage.from}`, {
         clientId: this.transport.clientId,
         transportMessage: initMessage,
         tags: ["invariant-violation"]
       });
-      this.abortStream(
-        initMessage.from,
-        initMessage.streamId,
-        Err({
-          code: INTERNAL_RIVER_ERROR_CODE,
-          message: errMessage
-        })
-      );
       return null;
     }
+    const sessionScopedSend = this.transport.getSessionBoundSendFn(
+      initMessage.from,
+      session.id
+    );
+    const cancelStream = (streamId, payload) => {
+      this.cancelStream(initMessage.from, sessionScopedSend, streamId, payload);
+    };
     const sessionMetadata = this.transport.sessionHandshakeMetadata.get(
       session.to
     );
@@ -1689,11 +1609,10 @@ var RiverServer = class {
         ...session.loggingMetadata,
         tags: ["invariant-violation"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
-          code: INTERNAL_RIVER_ERROR_CODE,
+          code: UNCAUGHT_ERROR_CODE,
           message: errMessage
         })
       );
@@ -1707,8 +1626,7 @@ var RiverServer = class {
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1721,12 +1639,10 @@ var RiverServer = class {
       const errMessage = `missing service name in stream open message`;
       this.log?.warn(errMessage, {
         ...session.loggingMetadata,
-        clientId: this.transport.clientId,
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1739,12 +1655,10 @@ var RiverServer = class {
       const errMessage = `missing procedure name in stream open message`;
       this.log?.warn(errMessage, {
         ...session.loggingMetadata,
-        clientId: this.transport.clientId,
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1761,8 +1675,7 @@ var RiverServer = class {
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1776,12 +1689,10 @@ var RiverServer = class {
       const errMessage = `couldn't find a matching procedure for ${initMessage.serviceName}.${initMessage.procedureName}`;
       this.log?.warn(errMessage, {
         ...session.loggingMetadata,
-        clientId: this.transport.clientId,
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1790,7 +1701,19 @@ var RiverServer = class {
       );
       return null;
     }
+    const serviceContext = this.getContext(service, initMessage.serviceName);
     const procedure = service.procedures[initMessage.procedureName];
+    if (!["rpc", "upload", "stream", "subscription"].includes(procedure.type)) {
+      this.log?.error(
+        `got request for invalid procedure type ${procedure.type} at ${initMessage.serviceName}.${initMessage.procedureName}`,
+        {
+          ...session.loggingMetadata,
+          transportMessage: initMessage,
+          tags: ["invariant-violation"]
+        }
+      );
+      return null;
+    }
     let passInitAsDataForBackwardsCompat = false;
     if (session.protocolVersion === "v1.1" && (procedure.type === "upload" || procedure.type === "stream") && import_value2.Value.Check(procedure.requestData, initMessage.payload) && import_value2.Value.Check(procedure.requestInit, {})) {
       passInitAsDataForBackwardsCompat = true;
@@ -1802,8 +1725,7 @@ var RiverServer = class {
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1813,37 +1735,33 @@ var RiverServer = class {
       return null;
     }
     return {
-      sessionMetadata,
-      procedure,
+      initialSession: session,
+      streamId: initMessage.streamId,
       procedureName: initMessage.procedureName,
-      service,
       serviceName: initMessage.serviceName,
-      loggingMetadata: {
-        ...session.loggingMetadata,
-        transportMessage: initMessage
-      },
-      streamId: initMessage.streamId,
-      controlFlags: initMessage.controlFlags,
       tracingCtx: initMessage.tracing,
       initPayload: initMessage.payload,
-      from: initMessage.from,
-      sessionId: session.id,
-      protocolVersion: session.protocolVersion,
+      sessionMetadata,
+      procedure,
+      serviceContext,
+      procClosesWithInit: isStreamCloseBackwardsCompat(
+        initMessage.controlFlags,
+        session.protocolVersion
+      ),
       passInitAsDataForBackwardsCompat
     };
   }
-  abortStream(to, streamId, payload) {
-    let abortedForSession = this.serverAbortedStreams.get(to);
-    if (!abortedForSession) {
-      abortedForSession = new LRUSet(this.maxAbortedStreamTombstonesPerSession);
-      this.serverAbortedStreams.set(to, abortedForSession);
+  cancelStream(to, sessionScopedSend, streamId, payload) {
+    let cancelledStreamsInSession = this.serverCancelledStreams.get(to);
+    if (!cancelledStreamsInSession) {
+      cancelledStreamsInSession = new LRUSet(
+        this.maxCancelledStreamTombstonesPerSession
+      );
+      this.serverCancelledStreams.set(to, cancelledStreamsInSession);
     }
-    abortedForSession.add(streamId);
-    this.transport.send(
-      to,
-      // TODO remove once clients migrate to v2
-      this.transport.sessions.get(to)?.protocolVersion === "v1.1" ? closeStreamMessage(streamId) : abortMessage(streamId, payload)
-    );
+    cancelledStreamsInSession.add(streamId);
+    const msg = cancelMessage(streamId, payload);
+    sessionScopedSend(msg);
   }
 };
 var LRUSet = class {
@@ -1868,21 +1786,21 @@ var LRUSet = class {
     return this.items.has(item);
   }
 };
-function isStreamAbortBackwardsCompat(controlFlags, protocolVersion) {
+function isStreamCancelBackwardsCompat(controlFlags, protocolVersion) {
   if (protocolVersion === "v1.1") {
     return false;
   }
-  return isStreamAbort(controlFlags);
+  return isStreamCancel(controlFlags);
 }
 function isStreamCloseBackwardsCompat(controlFlags, protocolVersion) {
   if (protocolVersion === "v1.1") {
-    return isStreamAbort(controlFlags);
+    return isStreamCancel(controlFlags);
   }
   return isStreamClose(controlFlags);
 }
 function getStreamCloseBackwardsCompat(protocolVersion) {
   if (protocolVersion === "v1.1") {
-    return 4 /* StreamAbortBit */;
+    return 4 /* StreamCancelBit */;
   }
   return 8 /* StreamClosedBit */;
 }
@@ -1892,7 +1810,7 @@ function createServer(transport, services, providedServerOptions) {
     services,
     providedServerOptions?.handshakeOptions,
     providedServerOptions?.extendedContext,
-    providedServerOptions?.maxAbortedStreamTombstonesPerSession
+    providedServerOptions?.maxCancelledStreamTombstonesPerSession
   );
 }
 
@@ -1905,15 +1823,13 @@ function createServerHandshakeOptions(schema, validate) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  ABORT_CODE,
+  CANCEL_CODE,
   Err,
-  INTERNAL_RIVER_ERROR_CODE,
   INVALID_REQUEST_CODE,
   Ok,
   Procedure,
   RIVER_VERSION,
-  RequestReaderErrorSchema,
-  ResponseReaderErrorSchema,
+  ReaderErrorSchema,
   ServiceSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
@@ -1921,6 +1837,9 @@ function createServerHandshakeOptions(schema, validate) {
   createClientHandshakeOptions,
   createServer,
   createServerHandshakeOptions,
-  serializeSchema
+  flattenErrorType,
+  serializeSchema,
+  serializeSchemaV1Compat,
+  unwrapOrThrow
 });
 //# sourceMappingURL=index.cjs.map