@replit/river 0.200.0-rc.9 → 0.200.1

package/dist/router/index.js

@@ -1,39 +1,49 @@
 import {
-  ABORT_CODE,
   AnyResultSchema,
+  CANCEL_CODE,
   Err,
   ErrResultSchema,
-  INTERNAL_RIVER_ERROR_CODE,
   INVALID_REQUEST_CODE,
   Ok,
-  Procedure,
-  ReadStreamImpl,
-  RequestReaderErrorSchema,
-  ResponseReaderErrorSchema,
+  ReadableImpl,
+  ReaderErrorSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
-  WriteStreamImpl
-} from "../chunk-MQ6ANR3H.js";
+  WritableImpl,
+  flattenErrorType,
+  unwrapOrThrow
+} from "../chunk-MADS7AI5.js";
 import {
   ControlMessageCloseSchema,
   ControlMessagePayloadSchema,
-  abortMessage,
+  cancelMessage,
   closeStreamMessage,
   coerceErrorString,
   createHandlerSpan,
   createProcTelemetryInfo,
   generateId,
   getPropagationContext,
-  isStreamAbort,
+  isStreamCancel,
   isStreamClose,
-  isStreamCloseRequest,
   isStreamOpen,
-  requestCloseStreamMessage,
   version
-} from "../chunk-EETL2L77.js";
+} from "../chunk-UQHYJZTP.js";
 
 // router/services.ts
 import { Type } from "@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 = Type.Strict(handshakeSchema);
+  }
+  return schema;
+}
 function serializeSchema(services, handshakeSchema) {
   const serializedServiceObject = Object.entries(services).reduce((acc, [name, value]) => {
     acc[name] = value.serialize();
@@ -170,7 +180,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(
@@ -283,9 +293,86 @@ var ServiceScaffold = class {
   }
 };
 
+// router/procedures.ts
+import { Type as Type2 } from "@sinclair/typebox";
+function rpc({
+  requestInit,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    ...description ? { description } : {},
+    type: "rpc",
+    requestInit,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function upload({
+  requestInit,
+  requestData,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "upload",
+    ...description ? { description } : {},
+    requestInit,
+    requestData,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function subscription({
+  requestInit,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "subscription",
+    ...description ? { description } : {},
+    requestInit,
+    responseData,
+    responseError,
+    handler
+  };
+}
+function stream({
+  requestInit,
+  requestData,
+  responseData,
+  responseError = Type2.Never(),
+  description,
+  handler
+}) {
+  return {
+    type: "stream",
+    ...description ? { description } : {},
+    requestInit,
+    requestData,
+    responseData,
+    responseError,
+    handler
+  };
+}
+var Procedure = {
+  rpc,
+  upload,
+  subscription,
+  stream
+};
+
 // router/client.ts
 import { Value } from "@sinclair/typebox/value";
-var OutputErrResultSchema = ErrResultSchema(ResponseReaderErrorSchema);
+var ReaderErrResultSchema = ErrResultSchema(ReaderErrorSchema);
 var noop = () => {
 };
 function _createRecursiveProxy(callback, path) {
@@ -346,6 +433,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(
@@ -356,61 +448,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"
         })
       )
     );
@@ -419,47 +511,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 (Value.Check(OutputErrResultSchema, msg.payload)) {
-        abortResult = msg.payload;
+      span.addEvent("received cancel");
+      let cancelResult;
+      if (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: [
-              ...Value.Errors(OutputErrResultSchema, msg.payload)
+              ...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
       });
@@ -467,7 +556,7 @@ function handleProc(procType, transport, serverId, init, serviceName, procedureN
     }
     if (!Value.Check(ControlMessageCloseSchema, msg.payload)) {
       if (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",
@@ -480,33 +569,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,
@@ -515,34 +607,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");
   }
@@ -550,25 +647,31 @@ async function getSingleMessage(resReader, log) {
 }
 
 // router/server.ts
+import { Type as Type3 } from "@sinclair/typebox";
 import { Value as Value2 } from "@sinclair/typebox/value";
 import { SpanStatusCode } from "@opentelemetry/api";
-var InputErrResultSchema = ErrResultSchema(RequestReaderErrorSchema);
+var CancelResultSchema = ErrResultSchema(
+  Type3.Object({
+    code: Type3.Literal(CANCEL_CODE),
+    message: Type3.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();
@@ -584,34 +687,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;
@@ -620,256 +729,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 (Value2.Check(InputErrResultSchema, msg.payload)) {
-          abortResult = msg.payload;
+      if (isStreamCancelBackwardsCompat(msg.controlFlags, protocolVersion)) {
+        let cancelResult;
+        if (Value2.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: [
-              ...Value2.Errors(InputErrResultSchema, msg.payload)
+              ...Value2.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 && Value2.Check(procedure.requestData, msg.payload)) {
-        reqReader.pushValue(Ok(msg.payload));
-      } else if (!Value2.Check(ControlMessagePayloadSchema, msg.payload)) {
-        const validationErrors = [
+        reqReadable._pushValue(Ok(msg.payload));
+        if (isStreamCloseBackwardsCompat(msg.controlFlags, protocolVersion)) {
+          closeReadable();
+        }
+        return;
+      }
+      if (Value2.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 = [
+          ...Value2.Errors(procedure.responseData, msg.payload)
+        ];
+      } else {
+        validationErrors = [
           ...Value2.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(
-            ...Value2.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: 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":
@@ -881,15 +982,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 {
@@ -908,10 +1008,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);
@@ -931,9 +1031,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);
@@ -952,16 +1052,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 {
@@ -970,16 +1069,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 context = this.contextMap.get(service);
@@ -996,22 +1087,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
     );
@@ -1021,11 +1110,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
         })
       );
@@ -1039,8 +1127,7 @@ var RiverServer = class {
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1053,12 +1140,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,
@@ -1071,12 +1156,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,
@@ -1093,8 +1176,7 @@ var RiverServer = class {
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1108,12 +1190,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,
@@ -1122,7 +1202,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") && Value2.Check(procedure.requestData, initMessage.payload) && Value2.Check(procedure.requestInit, {})) {
       passInitAsDataForBackwardsCompat = true;
@@ -1134,8 +1226,7 @@ var RiverServer = class {
         transportMessage: initMessage,
         tags: ["invalid-request"]
       });
-      this.abortStream(
-        initMessage.from,
+      cancelStream(
         initMessage.streamId,
         Err({
           code: INVALID_REQUEST_CODE,
@@ -1145,37 +1236,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 {
@@ -1200,21 +1287,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 */;
 }
@@ -1224,7 +1311,7 @@ function createServer(transport, services, providedServerOptions) {
     services,
     providedServerOptions?.handshakeOptions,
     providedServerOptions?.extendedContext,
-    providedServerOptions?.maxAbortedStreamTombstonesPerSession
+    providedServerOptions?.maxCancelledStreamTombstonesPerSession
   );
 }
 
@@ -1236,15 +1323,13 @@ function createServerHandshakeOptions(schema, validate) {
   return { schema, validate };
 }
 export {
-  ABORT_CODE,
+  CANCEL_CODE,
   Err,
-  INTERNAL_RIVER_ERROR_CODE,
   INVALID_REQUEST_CODE,
   Ok,
   Procedure,
   version as RIVER_VERSION,
-  RequestReaderErrorSchema,
-  ResponseReaderErrorSchema,
+  ReaderErrorSchema,
   ServiceSchema,
   UNCAUGHT_ERROR_CODE,
   UNEXPECTED_DISCONNECT_CODE,
@@ -1252,6 +1337,9 @@ export {
   createClientHandshakeOptions,
   createServer,
   createServerHandshakeOptions,
-  serializeSchema
+  flattenErrorType,
+  serializeSchema,
+  serializeSchemaV1Compat,
+  unwrapOrThrow
 };
 //# sourceMappingURL=index.js.map