@replit/river 0.10.13 → 0.12.0

package/dist/router/index.cjs

@@ -410,57 +410,58 @@ var TransportMessageSchema = (t) => import_typebox2.Type.Object({
   id: import_typebox2.Type.String(),
   from: import_typebox2.Type.String(),
   to: import_typebox2.Type.String(),
+  seq: import_typebox2.Type.Integer(),
+  ack: import_typebox2.Type.Integer(),
   serviceName: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()])),
   procedureName: import_typebox2.Type.Optional(import_typebox2.Type.Union([import_typebox2.Type.String(), import_typebox2.Type.Null()])),
   streamId: import_typebox2.Type.String(),
   controlFlags: import_typebox2.Type.Integer(),
   payload: t
 });
-var TransportAckSchema = TransportMessageSchema(
-  import_typebox2.Type.Object({
-    ack: import_typebox2.Type.String()
-  })
-);
-var ControlMessagePayloadSchema = import_typebox2.Type.Object({
+var ControlMessageAckSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("ACK")
+});
+var ControlMessageCloseSchema = import_typebox2.Type.Object({
   type: import_typebox2.Type.Literal("CLOSE")
 });
+var PROTOCOL_VERSION = "v1";
+var ControlMessageHandshakeRequestSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("HANDSHAKE_REQ"),
+  protocolVersion: import_typebox2.Type.Literal(PROTOCOL_VERSION)
+});
+var ControlMessageHandshakeResponseSchema = import_typebox2.Type.Object({
+  type: import_typebox2.Type.Literal("HANDSHAKE_RESP"),
+  status: import_typebox2.Type.Union([
+    import_typebox2.Type.Object({
+      ok: import_typebox2.Type.Literal(true),
+      instanceId: import_typebox2.Type.String()
+    }),
+    import_typebox2.Type.Object({
+      ok: import_typebox2.Type.Literal(false),
+      reason: import_typebox2.Type.Union([import_typebox2.Type.Literal("VERSION_MISMATCH")])
+    })
+  ])
+});
+var ControlMessagePayloadSchema = import_typebox2.Type.Union([
+  ControlMessageCloseSchema,
+  ControlMessageAckSchema,
+  ControlMessageHandshakeRequestSchema,
+  ControlMessageHandshakeResponseSchema
+]);
 var OpaqueTransportMessageSchema = TransportMessageSchema(
   import_typebox2.Type.Unknown()
 );
-function msg(from, to, streamId, payload, serviceName, procedureName) {
-  return {
-    id: (0, import_nanoid.nanoid)(),
-    to,
-    from,
-    serviceName,
-    procedureName,
-    streamId,
-    controlFlags: 0,
-    payload
-  };
-}
-function reply(msg2, response) {
-  return {
-    id: (0, import_nanoid.nanoid)(),
-    streamId: msg2.streamId,
-    controlFlags: 0,
-    to: msg2.from,
-    from: msg2.to,
-    payload: response
-  };
-}
-function closeStream(from, to, stream) {
-  const closeMessage = msg(from, to, stream, {
-    type: "CLOSE"
-  });
-  closeMessage.controlFlags |= 4 /* StreamClosedBit */;
-  return closeMessage;
-}
 function isStreamOpen(controlFlag) {
-  return (controlFlag & 2 /* StreamOpenBit */) === 2 /* StreamOpenBit */;
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 2 /* StreamOpenBit */) === 2 /* StreamOpenBit */
+  );
 }
 function isStreamClose(controlFlag) {
-  return (controlFlag & 4 /* StreamClosedBit */) === 4 /* StreamClosedBit */;
+  return (
+    /* eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison */
+    (controlFlag & 4 /* StreamClosedBit */) === 4 /* StreamClosedBit */
+  );
 }
 
 // router/client.ts
@@ -555,33 +556,24 @@ var createClient = (transport, serverId = "SERVER") => _createRecursiveProxy(asy
     throw new Error(`invalid river call, unknown procedure type ${procType}`);
   }
 }, []);
-var CONNECTION_GRACE_PERIOD_MS = 5e3;
-function rejectAfterDisconnectGrace(from, cb) {
-  let timeout = void 0;
+function createSessionDisconnectHandler(from, cb) {
   return (evt) => {
-    if (evt.status === "connect" && evt.conn.connectedTo === from) {
-      clearTimeout(timeout);
-      timeout = void 0;
-    }
-    if (evt.status === "disconnect" && evt.conn.connectedTo === from) {
-      timeout = setTimeout(cb, CONNECTION_GRACE_PERIOD_MS);
+    if (evt.status === "disconnect" && evt.session.to === from) {
+      cb();
     }
   };
 }
-function handleRpc(transport, serverId, input, serviceName, procName) {
+function handleRpc(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  const m = msg(
-    transport.clientId,
-    serverId,
+  transport.send(serverId, {
     streamId,
-    input,
     serviceName,
-    procName
-  );
-  m.controlFlags |= 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */;
-  transport.send(m);
+    procedureName,
+    payload: input,
+    controlFlags: 2 /* StreamOpenBit */ | 4 /* StreamClosedBit */
+  });
   const responsePromise = new Promise((resolve) => {
-    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
       cleanup();
       resolve(
         Err({
@@ -592,172 +584,181 @@ function handleRpc(transport, serverId, input, serviceName, procName) {
     });
     function cleanup() {
       transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("connectionStatus", onConnectionStatus);
+      transport.removeEventListener("sessionStatus", onSessionStatus);
     }
-    function onMessage(msg2) {
-      if (msg2.streamId !== streamId) {
+    function onMessage(msg) {
+      if (msg.streamId !== streamId) {
         return;
       }
-      if (msg2.to !== transport.clientId) {
+      if (msg.to !== transport.clientId) {
         return;
       }
-      if (msg2.streamId === streamId) {
+      if (msg.streamId === streamId) {
         cleanup();
-        resolve(msg2.payload);
+        resolve(msg.payload);
       }
     }
     transport.addEventListener("message", onMessage);
-    transport.addEventListener("connectionStatus", onConnectionStatus);
+    transport.addEventListener("sessionStatus", onSessionStatus);
   });
   return responsePromise;
 }
-function handleStream(transport, serverId, init, serviceName, procName) {
+function handleStream(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
   const inputStream = pushable({ objectMode: true });
   const outputStream = pushable({ objectMode: true });
   let firstMessage = true;
+  let healthyClose = true;
   if (init) {
-    const m = msg(
-      transport.clientId,
-      serverId,
+    transport.send(serverId, {
       streamId,
-      init,
       serviceName,
-      procName
-    );
-    m.controlFlags = 2 /* StreamOpenBit */;
-    transport.send(m);
+      procedureName,
+      payload: init,
+      controlFlags: 2 /* StreamOpenBit */
+    });
     firstMessage = false;
   }
-  (async () => {
+  const pipeInputToTransport = async () => {
     for await (const rawIn of inputStream) {
-      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      const m = {
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
+      };
       if (firstMessage) {
         m.serviceName = serviceName;
-        m.procedureName = procName;
+        m.procedureName = procedureName;
         m.controlFlags |= 2 /* StreamOpenBit */;
         firstMessage = false;
       }
-      transport.send(m);
+      transport.send(serverId, m);
     }
-    transport.send(closeStream(transport.clientId, serverId, streamId));
-  })();
-  function onMessage(msg2) {
-    if (msg2.streamId !== streamId) {
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
+  };
+  void pipeInputToTransport();
+  function onMessage(msg) {
+    if (msg.streamId !== streamId) {
       return;
     }
-    if (msg2.to !== transport.clientId) {
+    if (msg.to !== transport.clientId) {
       return;
     }
-    if (isStreamClose(msg2.controlFlags)) {
+    if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
-      outputStream.push(msg2.payload);
+      outputStream.push(msg.payload);
     }
   }
   function cleanup() {
     inputStream.end();
     outputStream.end();
     transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("connectionStatus", onConnectionStatus);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
   }
-  const closeHandler = () => {
-    cleanup();
-    transport.send(closeStream(transport.clientId, serverId, streamId));
-  };
-  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
     outputStream.push(
       Err({
         code: UNEXPECTED_DISCONNECT,
         message: `${serverId} unexpectedly disconnected`
       })
     );
+    healthyClose = false;
     cleanup();
   });
   transport.addEventListener("message", onMessage);
-  transport.addEventListener("connectionStatus", onConnectionStatus);
-  return [inputStream, outputStream, closeHandler];
+  transport.addEventListener("sessionStatus", onSessionStatus);
+  return [inputStream, outputStream, cleanup];
 }
-function handleSubscribe(transport, serverId, input, serviceName, procName) {
+function handleSubscribe(transport, serverId, input, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
-  const m = msg(
-    transport.clientId,
-    serverId,
+  transport.send(serverId, {
     streamId,
-    input,
     serviceName,
-    procName
-  );
-  m.controlFlags |= 2 /* StreamOpenBit */;
-  transport.send(m);
+    procedureName,
+    payload: input,
+    controlFlags: 2 /* StreamOpenBit */
+  });
+  let healthyClose = true;
   const outputStream = pushable({ objectMode: true });
-  function onMessage(msg2) {
-    if (msg2.streamId !== streamId) {
+  function onMessage(msg) {
+    if (msg.streamId !== streamId) {
       return;
     }
-    if (msg2.to !== transport.clientId) {
+    if (msg.to !== transport.clientId) {
       return;
     }
-    if (isStreamClose(msg2.controlFlags)) {
+    if (isStreamClose(msg.controlFlags)) {
       cleanup();
     } else {
-      outputStream.push(msg2.payload);
+      outputStream.push(msg.payload);
     }
   }
   function cleanup() {
     outputStream.end();
     transport.removeEventListener("message", onMessage);
-    transport.removeEventListener("connectionStatus", onConnectionStatus);
+    transport.removeEventListener("sessionStatus", onSessionStatus);
   }
   const closeHandler = () => {
     cleanup();
-    transport.send(closeStream(transport.clientId, serverId, streamId));
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
   };
-  const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+  const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
     outputStream.push(
       Err({
         code: UNEXPECTED_DISCONNECT,
         message: `${serverId} unexpectedly disconnected`
       })
     );
+    healthyClose = false;
     cleanup();
   });
   transport.addEventListener("message", onMessage);
-  transport.addEventListener("connectionStatus", onConnectionStatus);
+  transport.addEventListener("sessionStatus", onSessionStatus);
   return [outputStream, closeHandler];
 }
-function handleUpload(transport, serverId, input, serviceName, procName) {
+function handleUpload(transport, serverId, init, serviceName, procedureName) {
   const streamId = (0, import_nanoid2.nanoid)();
   const inputStream = pushable({ objectMode: true });
   let firstMessage = true;
-  if (input) {
-    const m = msg(
-      transport.clientId,
-      serverId,
+  let healthyClose = true;
+  if (init) {
+    transport.send(serverId, {
       streamId,
-      input,
       serviceName,
-      procName
-    );
-    m.controlFlags = 2 /* StreamOpenBit */;
-    transport.send(m);
+      procedureName,
+      payload: init,
+      controlFlags: 2 /* StreamOpenBit */
+    });
     firstMessage = false;
   }
-  (async () => {
+  const pipeInputToTransport = async () => {
     for await (const rawIn of inputStream) {
-      const m = msg(transport.clientId, serverId, streamId, rawIn);
+      const m = {
+        streamId,
+        payload: rawIn,
+        controlFlags: 0
+      };
       if (firstMessage) {
-        m.controlFlags |= 2 /* StreamOpenBit */;
         m.serviceName = serviceName;
-        m.procedureName = procName;
+        m.procedureName = procedureName;
+        m.controlFlags |= 2 /* StreamOpenBit */;
         firstMessage = false;
       }
-      transport.send(m);
+      transport.send(serverId, m);
     }
-    transport.send(closeStream(transport.clientId, serverId, streamId));
-  })();
+    if (!healthyClose)
+      return;
+    transport.sendCloseStream(serverId, streamId);
+  };
+  void pipeInputToTransport();
   const responsePromise = new Promise((resolve) => {
-    const onConnectionStatus = rejectAfterDisconnectGrace(serverId, () => {
+    const onSessionStatus = createSessionDisconnectHandler(serverId, () => {
+      healthyClose = false;
       cleanup();
       resolve(
         Err({
@@ -769,19 +770,19 @@ function handleUpload(transport, serverId, input, serviceName, procName) {
     function cleanup() {
       inputStream.end();
       transport.removeEventListener("message", onMessage);
-      transport.removeEventListener("connectionStatus", onConnectionStatus);
+      transport.removeEventListener("sessionStatus", onSessionStatus);
     }
-    function onMessage(msg2) {
-      if (msg2.to !== transport.clientId) {
+    function onMessage(msg) {
+      if (msg.to !== transport.clientId) {
         return;
       }
-      if (msg2.streamId === streamId) {
+      if (msg.streamId === streamId) {
         cleanup();
-        resolve(msg2.payload);
+        resolve(msg.payload);
       }
     }
     transport.addEventListener("message", onMessage);
-    transport.addEventListener("connectionStatus", onConnectionStatus);
+    transport.addEventListener("sessionStatus", onSessionStatus);
   });
   return [inputStream, responsePromise];
 }
@@ -791,6 +792,16 @@ var log;
 
 // router/server.ts
 var import_value = require("@sinclair/typebox/value");
+
+// util/stringify.ts
+function coerceErrorString(err) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return `[coerced to error] ${String(err)}`;
+}
+
+// router/server.ts
 var RiverServer = class {
   transport;
   services;
@@ -799,10 +810,12 @@ var RiverServer = class {
   streamMap;
   // map of client to their open streams by streamId
   clientStreams;
+  disconnectedSessions;
   constructor(transport, services, extendedContext) {
     this.transport = transport;
     this.services = services;
     this.contextMap = /* @__PURE__ */ new Map();
+    this.disconnectedSessions = /* @__PURE__ */ new Set();
     for (const service of Object.values(services)) {
       this.contextMap.set(service, {
         ...extendedContext,
@@ -811,13 +824,13 @@ var RiverServer = class {
     }
     this.streamMap = /* @__PURE__ */ new Map();
     this.clientStreams = /* @__PURE__ */ new Map();
-    this.transport.addEventListener("message", this.handler);
-    this.transport.addEventListener("connectionStatus", this.onDisconnect);
+    this.transport.addEventListener("message", this.onMessage);
+    this.transport.addEventListener("sessionStatus", this.onSessionStatus);
   }
   get streams() {
     return this.streamMap;
   }
-  handler = async (message) => {
+  onMessage = async (message) => {
     if (message.to !== this.transport.clientId) {
       log?.info(
         `${this.transport.clientId} -- got msg with destination that isn't the server, ignoring`
@@ -832,12 +845,12 @@ var RiverServer = class {
     }
     await this.pushToStream(procStream, message, isInitMessage);
   };
-  // cleanup streams on unexpected disconnections
-  onDisconnect = async (evt) => {
+  // cleanup streams on session close
+  onSessionStatus = async (evt) => {
     if (evt.status !== "disconnect") {
       return;
     }
-    const disconnectedClientId = evt.conn.connectedTo;
+    const disconnectedClientId = evt.session.to;
     log?.info(
       `${this.transport.clientId} -- got unexpected disconnect from ${disconnectedClientId}, cleaning up streams`
     );
@@ -845,14 +858,16 @@ var RiverServer = class {
     if (!streamsFromThisClient) {
       return;
     }
+    this.disconnectedSessions.add(disconnectedClientId);
     await Promise.all(
       Array.from(streamsFromThisClient).map(this.cleanupStream)
     );
+    this.disconnectedSessions.delete(disconnectedClientId);
     this.clientStreams.delete(disconnectedClientId);
   };
   async close() {
-    this.transport.removeEventListener("message", this.handler);
-    this.transport.removeEventListener("connectionStatus", this.onDisconnect);
+    this.transport.removeEventListener("message", this.onMessage);
+    this.transport.removeEventListener("sessionStatus", this.onSessionStatus);
     await Promise.all([...this.streamMap.keys()].map(this.cleanupStream));
   }
   createNewProcStream(message) {
@@ -876,6 +891,13 @@ var RiverServer = class {
       );
       return;
     }
+    const session = this.transport.sessions.get(message.from);
+    if (!session) {
+      log?.warn(
+        `${this.transport.clientId} -- couldn't find session for ${message.from}`
+      );
+      return;
+    }
     const procedure = service.procedures[message.procedureName];
     const incoming = pushable({ objectMode: true });
     const outgoing = pushable({ objectMode: true });
@@ -883,21 +905,20 @@ var RiverServer = class {
       // sending outgoing messages back to client
       (async () => {
         for await (const response of outgoing) {
-          this.transport.send(reply(message, response));
+          this.transport.send(session.to, {
+            streamId: message.streamId,
+            controlFlags: 0,
+            payload: response
+          });
         }
-        if (procedure.type === "subscription" || procedure.type === "stream") {
-          this.transport.send(
-            closeStream(
-              this.transport.clientId,
-              message.from,
-              message.streamId
-            )
-          );
+        const needsClose = procedure.type === "subscription" || procedure.type === "stream";
+        if (needsClose && !this.disconnectedSessions.has(message.from)) {
+          this.transport.sendCloseStream(session.to, message.streamId);
         }
       })()
     );
     const errorHandler = (err) => {
-      const errorMsg = err instanceof Error ? err.message : `[coerced to error] ${err}`;
+      const errorMsg = coerceErrorString(err);
       log?.error(
         `${this.transport.clientId} -- procedure ${message.serviceName}.${message.procedureName}:${message.streamId} threw an error: ${errorMsg}`
       );
@@ -910,82 +931,95 @@ var RiverServer = class {
     };
     let inputHandler;
     const procHasInitMessage = "init" in procedure;
-    if (procedure.type === "stream") {
-      if (procHasInitMessage) {
-        inputHandler = (async () => {
-          const initMessage = await incoming.next();
-          if (initMessage.done) {
-            return;
-          }
-          return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
-        })();
-      } else {
-        inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
-      }
-    } else if (procedure.type === "rpc") {
-      inputHandler = (async () => {
-        const inputMessage = await incoming.next();
-        if (inputMessage.done) {
-          return;
-        }
-        try {
-          const outputMessage = await procedure.handler(
-            serviceContext,
-            inputMessage.value
-          );
-          outgoing.push(outputMessage);
-        } catch (err) {
-          errorHandler(err);
-        }
-      })();
-    } else if (procedure.type === "subscription") {
-      inputHandler = (async () => {
-        const inputMessage = await incoming.next();
-        if (inputMessage.done) {
-          return;
-        }
-        try {
-          await procedure.handler(serviceContext, inputMessage.value, outgoing);
-        } catch (err) {
-          errorHandler(err);
-        }
-      })();
-    } else if (procedure.type === "upload") {
-      if (procHasInitMessage) {
+    switch (procedure.type) {
+      case "rpc":
         inputHandler = (async () => {
-          const initMessage = await incoming.next();
-          if (initMessage.done) {
+          const inputMessage = await incoming.next();
+          if (inputMessage.done) {
             return;
           }
           try {
             const outputMessage = await procedure.handler(
               serviceContext,
-              initMessage.value,
-              incoming
+              inputMessage.value
             );
             outgoing.push(outputMessage);
           } catch (err) {
             errorHandler(err);
           }
         })();
-      } else {
+        break;
+      case "stream":
+        if (procHasInitMessage) {
+          inputHandler = (async () => {
+            const initMessage = await incoming.next();
+            if (initMessage.done) {
+              return;
+            }
+            return procedure.handler(serviceContext, initMessage.value, incoming, outgoing).catch(errorHandler);
+          })();
+        } else {
+          inputHandler = procedure.handler(serviceContext, incoming, outgoing).catch(errorHandler);
+        }
+        break;
+      case "subscription":
         inputHandler = (async () => {
+          const inputMessage = await incoming.next();
+          if (inputMessage.done) {
+            return;
+          }
           try {
-            const outputMessage = await procedure.handler(
+            await procedure.handler(
               serviceContext,
-              incoming
+              inputMessage.value,
+              outgoing
             );
-            outgoing.push(outputMessage);
           } catch (err) {
             errorHandler(err);
           }
         })();
-      }
-    } else {
-      log?.warn(
-        `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
-      );
-      return;
+        break;
+      case "upload":
+        if (procHasInitMessage) {
+          inputHandler = (async () => {
+            const initMessage = await incoming.next();
+            if (initMessage.done) {
+              return;
+            }
+            try {
+              const outputMessage = await procedure.handler(
+                serviceContext,
+                initMessage.value,
+                incoming
+              );
+              if (!this.disconnectedSessions.has(message.from)) {
+                outgoing.push(outputMessage);
+              }
+            } catch (err) {
+              errorHandler(err);
+            }
+          })();
+        } else {
+          inputHandler = (async () => {
+            try {
+              const outputMessage = await procedure.handler(
+                serviceContext,
+                incoming
+              );
+              if (!this.disconnectedSessions.has(message.from)) {
+                outgoing.push(outputMessage);
+              }
+            } catch (err) {
+              errorHandler(err);
+            }
+          })();
+        }
+        break;
+      default:
+        log?.warn(
+          `${this.transport.clientId} -- got request for invalid procedure type ${procedure.type} at ${message.serviceName}.${message.procedureName}`
+        );
+        return;
     }
     const procStream = {
       id: message.streamId,
@@ -993,7 +1027,6 @@ var RiverServer = class {
       outgoing,
       serviceName: message.serviceName,
       procedureName: message.procedureName,
-      procedure,
       promises: { inputHandler, outputHandler }
     };
     this.streamMap.set(message.streamId, procStream);
@@ -1003,13 +1036,18 @@ var RiverServer = class {
     return procStream;
   }
   async pushToStream(procStream, message, isInit) {
-    const procedure = procStream.procedure;
+    const { serviceName, procedureName } = procStream;
+    const procedure = this.services[serviceName].procedures[procedureName];
     const procHasInitMessage = "init" in procedure;
-    if (isInit && procHasInitMessage && import_value.Value.Check(procedure.init, message.payload) || import_value.Value.Check(procedure.input, message.payload)) {
+    if (isInit && procHasInitMessage && import_value.Value.Check(procedure.init, message.payload)) {
+      procStream.incoming.push(message.payload);
+    } else if (import_value.Value.Check(procedure.input, message.payload)) {
       procStream.incoming.push(message.payload);
     } else if (!import_value.Value.Check(ControlMessagePayloadSchema, message.payload)) {
       log?.error(
-        `${this.transport.clientId} -- procedure ${procStream.serviceName}.${procStream.procedureName} received invalid payload: ${JSON.stringify(message.payload)}`
+        `${this.transport.clientId} -- procedure ${serviceName}.${procedureName} received invalid payload: ${JSON.stringify(
+          message.payload
+        )}`
       );
     }
     if (isStreamClose(message.controlFlags)) {